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.
21 #include <sys/types.h>
27 #include "libmemcached/common.h"
29 #include <libtest/server.h>
31 #include "clients/generator.h"
32 #include "clients/execute.h"
34 #define SMALL_STRING_LEN 1024
36 #include <libtest/test.h>
37 #include "tests/parser.h"
38 #include "tests/string.h"
39 #include "tests/replication.h"
40 #include "tests/basic.h"
41 #include "tests/error_conditions.h"
42 #include "tests/print.h"
43 #include "tests/virtual_buckets.h"
46 #ifdef HAVE_LIBMEMCACHEDUTIL
48 #include "libmemcached/memcached_util.h"
51 #include "hash_results.h"
53 #define GLOBAL_COUNT 10000
54 #define GLOBAL2_COUNT 100
55 #define SERVERS_TO_CREATE 5
56 static uint32_t global_count
;
58 static pairs_st
*global_pairs
;
59 static const char *global_keys
[GLOBAL_COUNT
];
60 static size_t global_keys_length
[GLOBAL_COUNT
];
63 static test_return_t
pre_binary(memcached_st
*memc
);
66 static test_return_t
init_test(memcached_st
*not_used
)
71 (void)memcached_create(&memc
);
72 memcached_free(&memc
);
77 static test_return_t
server_list_null_test(memcached_st
*ptr
)
79 memcached_server_st
*server_list
;
80 memcached_return_t rc
;
83 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, NULL
);
84 test_true(server_list
== NULL
);
86 server_list
= memcached_server_list_append_with_weight(NULL
, "localhost", 0, 0, NULL
);
87 test_true(server_list
== NULL
);
89 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, &rc
);
90 test_true(server_list
== NULL
);
95 #define TEST_PORT_COUNT 7
96 in_port_t test_ports
[TEST_PORT_COUNT
];
98 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
99 const memcached_server_st
*server
,
103 size_t bigger
= *((size_t *)(context
));
105 assert(bigger
<= memcached_server_port(server
));
106 *((size_t *)(context
))= memcached_server_port(server
);
108 return MEMCACHED_SUCCESS
;
111 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
112 const memcached_server_st
*instance
,
116 FILE *stream
= (FILE *)context
;
119 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
120 memcached_server_name(instance
),
121 memcached_server_port(instance
),
122 instance
->major_version
,
123 instance
->minor_version
,
124 instance
->micro_version
);
126 return MEMCACHED_SUCCESS
;
129 static test_return_t
server_sort_test(memcached_st
*ptr
)
131 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
133 memcached_return_t rc
;
134 memcached_server_fn callbacks
[1];
135 memcached_st
*local_memc
;
138 local_memc
= memcached_create(NULL
);
139 test_true(local_memc
);
140 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
142 for (size_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
144 test_ports
[x
]= (in_port_t
)random() % 64000;
145 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
146 test_true(memcached_server_count(local_memc
) == x
+ 1);
148 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
150 test_true(rc
== MEMCACHED_SUCCESS
);
153 callbacks
[0]= server_display_function
;
154 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
157 memcached_free(local_memc
);
162 static test_return_t
server_sort2_test(memcached_st
*ptr
)
164 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
165 memcached_return_t rc
;
166 memcached_server_fn callbacks
[1];
167 memcached_st
*local_memc
;
168 memcached_server_instance_st instance
;
171 local_memc
= memcached_create(NULL
);
172 test_true(local_memc
);
173 rc
= memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
174 test_true(rc
== MEMCACHED_SUCCESS
);
176 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
177 test_true(rc
== MEMCACHED_SUCCESS
);
178 instance
= memcached_server_instance_by_position(local_memc
, 0);
179 test_true(memcached_server_port(instance
) == 43043);
181 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
182 test_true(rc
== MEMCACHED_SUCCESS
);
184 instance
= memcached_server_instance_by_position(local_memc
, 0);
185 test_true(memcached_server_port(instance
) == 43042);
187 instance
= memcached_server_instance_by_position(local_memc
, 1);
188 test_true(memcached_server_port(instance
) == 43043);
190 callbacks
[0]= server_display_function
;
191 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
194 memcached_free(local_memc
);
199 static test_return_t
memcached_server_remove_test(memcached_st
*ptr
)
201 memcached_return_t rc
;
202 memcached_st local_memc
;
204 memcached_server_st
*servers
;
205 memcached_server_fn callbacks
[1];
207 const char *server_string
= "localhost:4444, localhost:4445, localhost:4446, localhost:4447, localhost, 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";
210 memc
= memcached_create(&local_memc
);
212 servers
= memcached_servers_parse(server_string
);
215 rc
= memcached_server_push(memc
, servers
);
216 memcached_server_list_free(servers
);
218 callbacks
[0]= server_print_callback
;
219 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
221 memcached_free(memc
);
226 static memcached_return_t
server_display_unsort_function(const memcached_st
*ptr
,
227 const memcached_server_st
*server
,
231 uint32_t x
= *((uint32_t *)(context
));
234 assert(test_ports
[x
] == server
->port
);
235 *((uint32_t *)(context
))= ++x
;
237 return MEMCACHED_SUCCESS
;
240 static test_return_t
server_unsort_test(memcached_st
*ptr
)
242 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
243 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
244 memcached_return_t rc
;
245 memcached_server_fn callbacks
[1];
246 memcached_st
*local_memc
;
249 local_memc
= memcached_create(NULL
);
250 test_true(local_memc
);
252 for (size_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
254 test_ports
[x
]= (in_port_t
)(random() % 64000);
255 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
256 test_true(memcached_server_count(local_memc
) == x
+1);
258 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
260 test_true(rc
== MEMCACHED_SUCCESS
);
263 callbacks
[0]= server_display_unsort_function
;
264 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
266 /* Now we sort old data! */
267 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
268 callbacks
[0]= server_display_function
;
269 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
272 memcached_free(local_memc
);
277 static test_return_t
allocation_test(memcached_st
*not_used
)
281 memc
= memcached_create(NULL
);
283 memcached_free(memc
);
288 static test_return_t
clone_test(memcached_st
*memc
)
292 memcached_st
*memc_clone
;
293 memc_clone
= memcached_clone(NULL
, NULL
);
294 test_true(memc_clone
);
295 memcached_free(memc_clone
);
298 /* Can we init from null? */
300 memcached_st
*memc_clone
;
301 memc_clone
= memcached_clone(NULL
, memc
);
302 test_true(memc_clone
);
305 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
306 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
307 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
308 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
311 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
312 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
313 test_true(memc_clone
->distribution
== memc
->distribution
);
314 { // Test all of the flags
315 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
316 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
317 test_true(memc_clone
->flags
.reuse_memory
== memc
->flags
.reuse_memory
);
318 test_true(memc_clone
->flags
.use_cache_lookups
== memc
->flags
.use_cache_lookups
);
319 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
320 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
321 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
322 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
323 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
324 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
325 test_true(memc_clone
->flags
.hash_with_prefix_key
== memc
->flags
.hash_with_prefix_key
);
326 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
327 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
328 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
329 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
331 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
332 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
333 test_true(hashkit_compare(&memc_clone
->distribution_hashkit
, &memc
->distribution_hashkit
));
334 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
335 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
336 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
337 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
338 test_true(memc_clone
->on_clone
== memc
->on_clone
);
339 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
340 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
341 test_true(memc_clone
->recv_size
== memc
->recv_size
);
342 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
343 test_true(memc_clone
->send_size
== memc
->send_size
);
344 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
345 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
346 test_true(memc_clone
->user_data
== memc
->user_data
);
348 memcached_free(memc_clone
);
351 /* Can we init from struct? */
353 memcached_st declared_clone
;
354 memcached_st
*memc_clone
;
355 memset(&declared_clone
, 0 , sizeof(memcached_st
));
356 memc_clone
= memcached_clone(&declared_clone
, NULL
);
357 test_true(memc_clone
);
358 memcached_free(memc_clone
);
361 /* Can we init from struct? */
363 memcached_st declared_clone
;
364 memcached_st
*memc_clone
;
365 memset(&declared_clone
, 0 , sizeof(memcached_st
));
366 memc_clone
= memcached_clone(&declared_clone
, memc
);
367 test_true(memc_clone
);
368 memcached_free(memc_clone
);
374 static test_return_t
userdata_test(memcached_st
*memc
)
377 test_true(memcached_set_user_data(memc
, foo
) == NULL
);
378 test_true(memcached_get_user_data(memc
) == foo
);
379 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
384 static test_return_t
connection_test(memcached_st
*memc
)
386 memcached_return_t rc
;
388 rc
= memcached_server_add_with_weight(memc
, "localhost", 0, 0);
389 test_true(rc
== MEMCACHED_SUCCESS
);
394 static test_return_t
error_test(memcached_st
*memc
)
396 memcached_return_t rc
;
397 uint32_t values
[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U,
398 982370485U, 1263635348U, 4242906218U, 3829656100U,
399 1891735253U, 334139633U, 2257084983U, 3088286104U,
400 13199785U, 2542027183U, 1097051614U, 199566778U,
401 2748246961U, 2465192557U, 1664094137U, 2405439045U,
402 1842224848U, 692413798U, 3479807801U, 919913813U,
403 4269430871U, 610793021U, 527273862U, 1437122909U,
404 2300930706U, 2943759320U, 674306647U, 2400528935U,
405 54481931U, 4186304426U, 1741088401U, 2979625118U,
406 4159057246U, 3425930182U, 2593724503U, 1868899624U,
407 1769812374U, 2302537950U, 1110330676U, 3365377466U,
408 1336171666U, 3021258493U, 3365377466U };
410 // You have updated the memcache_error messages but not updated docs/tests.
411 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
414 const char *msg
= memcached_strerror(memc
, rc
);
415 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
416 MEMCACHED_HASH_JENKINS
);
417 if (values
[rc
] != hash_val
)
419 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the error_test\n");
420 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, rc
), hash_val
);
422 test_true(values
[rc
] == hash_val
);
424 test_true(MEMCACHED_MAXIMUM_RETURN
== 46);
429 static test_return_t
set_test(memcached_st
*memc
)
431 memcached_return_t rc
;
432 const char *key
= "foo";
433 const char *value
= "when we sanitize";
435 rc
= memcached_set(memc
, key
, strlen(key
),
436 value
, strlen(value
),
437 (time_t)0, (uint32_t)0);
438 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
443 static test_return_t
append_test(memcached_st
*memc
)
445 memcached_return_t rc
;
446 const char *key
= "fig";
447 const char *in_value
= "we";
448 char *out_value
= NULL
;
452 rc
= memcached_flush(memc
, 0);
453 test_true(rc
== MEMCACHED_SUCCESS
);
455 rc
= memcached_set(memc
, key
, strlen(key
),
456 in_value
, strlen(in_value
),
457 (time_t)0, (uint32_t)0);
458 test_true(rc
== MEMCACHED_SUCCESS
);
460 rc
= memcached_append(memc
, key
, strlen(key
),
461 " the", strlen(" the"),
462 (time_t)0, (uint32_t)0);
463 test_true(rc
== MEMCACHED_SUCCESS
);
465 rc
= memcached_append(memc
, key
, strlen(key
),
466 " people", strlen(" people"),
467 (time_t)0, (uint32_t)0);
468 test_true(rc
== MEMCACHED_SUCCESS
);
470 out_value
= memcached_get(memc
, key
, strlen(key
),
471 &value_length
, &flags
, &rc
);
472 test_true(!memcmp(out_value
, "we the people", strlen("we the people")));
473 test_true(strlen("we the people") == value_length
);
474 test_true(rc
== MEMCACHED_SUCCESS
);
480 static test_return_t
append_binary_test(memcached_st
*memc
)
482 memcached_return_t rc
;
483 const char *key
= "numbers";
484 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
490 rc
= memcached_flush(memc
, 0);
491 test_true(rc
== MEMCACHED_SUCCESS
);
493 rc
= memcached_set(memc
,
496 (time_t)0, (uint32_t)0);
497 test_true(rc
== MEMCACHED_SUCCESS
);
499 for (x
= 0; store_list
[x
] ; x
++)
501 rc
= memcached_append(memc
,
503 (char *)&store_list
[x
], sizeof(uint32_t),
504 (time_t)0, (uint32_t)0);
505 test_true(rc
== MEMCACHED_SUCCESS
);
508 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
509 &value_length
, &flags
, &rc
);
510 test_true((value_length
== (sizeof(uint32_t) * x
)));
511 test_true(rc
== MEMCACHED_SUCCESS
);
513 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
515 test_true(*ptr
== store_list
[x
- counter
]);
523 static test_return_t
cas2_test(memcached_st
*memc
)
525 memcached_return_t rc
;
526 const char *keys
[]= {"fudge", "son", "food"};
527 size_t key_length
[]= {5, 3, 4};
528 const char *value
= "we the people";
529 size_t value_length
= strlen("we the people");
531 memcached_result_st results_obj
;
532 memcached_result_st
*results
;
535 rc
= memcached_flush(memc
, 0);
536 test_true(rc
== MEMCACHED_SUCCESS
);
538 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
540 for (x
= 0; x
< 3; x
++)
542 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
543 keys
[x
], key_length
[x
],
544 (time_t)50, (uint32_t)9);
545 test_true(rc
== MEMCACHED_SUCCESS
);
548 rc
= memcached_mget(memc
, keys
, key_length
, 3);
550 results
= memcached_result_create(memc
, &results_obj
);
552 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
554 test_true(results
->item_cas
);
555 test_true(rc
== MEMCACHED_SUCCESS
);
556 test_true(memcached_result_cas(results
));
558 test_true(!memcmp(value
, "we the people", strlen("we the people")));
559 test_true(strlen("we the people") == value_length
);
560 test_true(rc
== MEMCACHED_SUCCESS
);
562 memcached_result_free(&results_obj
);
567 static test_return_t
cas_test(memcached_st
*memc
)
569 memcached_return_t rc
;
570 const char *key
= "fun";
571 size_t key_length
= strlen(key
);
572 const char *value
= "we the people";
573 const char* keys
[2] = { key
, NULL
};
574 size_t keylengths
[2] = { strlen(key
), 0 };
575 size_t value_length
= strlen(value
);
576 const char *value2
= "change the value";
577 size_t value2_length
= strlen(value2
);
579 memcached_result_st results_obj
;
580 memcached_result_st
*results
;
583 rc
= memcached_flush(memc
, 0);
584 test_true(rc
== MEMCACHED_SUCCESS
);
586 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
588 rc
= memcached_set(memc
, key
, strlen(key
),
589 value
, strlen(value
),
590 (time_t)0, (uint32_t)0);
591 test_true(rc
== MEMCACHED_SUCCESS
);
593 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
595 results
= memcached_result_create(memc
, &results_obj
);
597 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
599 test_true(rc
== MEMCACHED_SUCCESS
);
600 test_true(memcached_result_cas(results
));
601 test_true(!memcmp(value
, memcached_result_value(results
), value_length
));
602 test_true(strlen(memcached_result_value(results
)) == value_length
);
603 test_true(rc
== MEMCACHED_SUCCESS
);
604 uint64_t cas
= memcached_result_cas(results
);
607 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
608 test_true(rc
== MEMCACHED_END
);
609 test_true(results
== NULL
);
612 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
613 test_true(rc
== MEMCACHED_SUCCESS
);
616 * The item will have a new cas value, so try to set it again with the old
617 * value. This should fail!
619 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
620 test_true(rc
== MEMCACHED_DATA_EXISTS
);
622 memcached_result_free(&results_obj
);
627 static test_return_t
prepend_test(memcached_st
*memc
)
629 memcached_return_t rc
;
630 const char *key
= "fig";
631 const char *value
= "people";
632 char *out_value
= NULL
;
636 rc
= memcached_flush(memc
, 0);
637 test_true(rc
== MEMCACHED_SUCCESS
);
639 rc
= memcached_set(memc
, key
, strlen(key
),
640 value
, strlen(value
),
641 (time_t)0, (uint32_t)0);
642 test_true(rc
== MEMCACHED_SUCCESS
);
644 rc
= memcached_prepend(memc
, key
, strlen(key
),
645 "the ", strlen("the "),
646 (time_t)0, (uint32_t)0);
647 test_true(rc
== MEMCACHED_SUCCESS
);
649 rc
= memcached_prepend(memc
, key
, strlen(key
),
650 "we ", strlen("we "),
651 (time_t)0, (uint32_t)0);
652 test_true(rc
== MEMCACHED_SUCCESS
);
654 out_value
= memcached_get(memc
, key
, strlen(key
),
655 &value_length
, &flags
, &rc
);
656 test_true(!memcmp(out_value
, "we the people", strlen("we the people")));
657 test_true(strlen("we the people") == value_length
);
658 test_true(rc
== MEMCACHED_SUCCESS
);
665 Set the value, then quit to make sure it is flushed.
666 Come back in and test that add fails.
668 static test_return_t
add_test(memcached_st
*memc
)
670 memcached_return_t rc
;
671 const char *key
= "foo";
672 const char *value
= "when we sanitize";
673 unsigned long long setting_value
;
675 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
677 rc
= memcached_set(memc
, key
, strlen(key
),
678 value
, strlen(value
),
679 (time_t)0, (uint32_t)0);
680 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
681 memcached_quit(memc
);
682 rc
= memcached_add(memc
, key
, strlen(key
),
683 value
, strlen(value
),
684 (time_t)0, (uint32_t)0);
686 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
689 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
693 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
700 ** There was a problem of leaking filedescriptors in the initial release
701 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
702 ** systems it seems that the kernel is slow on reclaiming the resources
703 ** because the connects starts to time out (the test doesn't do much
704 ** anyway, so just loop 10 iterations)
706 static test_return_t
add_wrapper(memcached_st
*memc
)
708 unsigned int max
= 10000;
716 for (uint32_t x
= 0; x
< max
; x
++)
722 static test_return_t
replace_test(memcached_st
*memc
)
724 memcached_return_t rc
;
725 const char *key
= "foo";
726 const char *value
= "when we sanitize";
727 const char *original
= "first we insert some data";
729 rc
= memcached_set(memc
, key
, strlen(key
),
730 original
, strlen(original
),
731 (time_t)0, (uint32_t)0);
732 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
734 rc
= memcached_replace(memc
, key
, strlen(key
),
735 value
, strlen(value
),
736 (time_t)0, (uint32_t)0);
737 test_true(rc
== MEMCACHED_SUCCESS
);
742 static test_return_t
delete_test(memcached_st
*memc
)
744 memcached_return_t rc
;
745 const char *key
= "foo";
746 const char *value
= "when we sanitize";
748 rc
= memcached_set(memc
, key
, strlen(key
),
749 value
, strlen(value
),
750 (time_t)0, (uint32_t)0);
751 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
753 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
754 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
759 static test_return_t
flush_test(memcached_st
*memc
)
761 memcached_return_t rc
;
763 rc
= memcached_flush(memc
, 0);
764 test_true(rc
== MEMCACHED_SUCCESS
);
769 static memcached_return_t
server_function(const memcached_st
*ptr
,
770 const memcached_server_st
*server
,
773 (void)ptr
; (void)server
; (void)context
;
776 return MEMCACHED_SUCCESS
;
779 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
782 strncpy(context
, "foo bad", sizeof(context
));
783 memcached_server_fn callbacks
[1];
785 callbacks
[0]= server_function
;
786 memcached_server_cursor(memc
, callbacks
, context
, 1);
790 static test_return_t
bad_key_test(memcached_st
*memc
)
792 memcached_return_t rc
;
793 const char *key
= "foo bad";
795 size_t string_length
;
797 memcached_st
*memc_clone
;
799 size_t max_keylen
= 0xffff;
801 // Just skip if we are in binary mode.
802 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
805 memc_clone
= memcached_clone(NULL
, memc
);
806 test_true(memc_clone
);
808 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
809 test_true(rc
== MEMCACHED_SUCCESS
);
811 /* All keys are valid in the binary protocol (except for length) */
812 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 0)
814 string
= memcached_get(memc_clone
, key
, strlen(key
),
815 &string_length
, &flags
, &rc
);
816 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
817 test_true(string_length
== 0);
821 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
822 test_true(rc
== MEMCACHED_SUCCESS
);
823 string
= memcached_get(memc_clone
, key
, strlen(key
),
824 &string_length
, &flags
, &rc
);
825 test_true(rc
== MEMCACHED_NOTFOUND
);
826 test_true(string_length
== 0);
829 /* Test multi key for bad keys */
830 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
831 size_t key_lengths
[] = { 7, 7, 7 };
833 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
834 test_true(rc
== MEMCACHED_SUCCESS
);
836 rc
= memcached_mget(memc_clone
, keys
, key_lengths
, 3);
837 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
839 rc
= memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1);
840 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
844 /* The following test should be moved to the end of this function when the
845 memcached server is updated to allow max size length of the keys in the
848 rc
= memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
849 test_true(rc
== MEMCACHED_SUCCESS
);
851 char *longkey
= (char *)malloc(max_keylen
+ 1);
854 memset(longkey
, 'a', max_keylen
+ 1);
855 string
= memcached_get(memc_clone
, longkey
, max_keylen
,
856 &string_length
, &flags
, &rc
);
857 test_true(rc
== MEMCACHED_NOTFOUND
);
858 test_true(string_length
== 0);
861 string
= memcached_get(memc_clone
, longkey
, max_keylen
+ 1,
862 &string_length
, &flags
, &rc
);
863 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
864 test_true(string_length
== 0);
871 /* Make sure zero length keys are marked as bad */
873 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
874 test_true(rc
== MEMCACHED_SUCCESS
);
875 string
= memcached_get(memc_clone
, key
, 0,
876 &string_length
, &flags
, &rc
);
877 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
878 test_true(string_length
== 0);
881 memcached_free(memc_clone
);
886 #define READ_THROUGH_VALUE "set for me"
887 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
890 memcached_result_st
*result
)
892 (void)memc
;(void)key
;(void)key_length
;
893 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
896 static test_return_t
read_through(memcached_st
*memc
)
898 memcached_return_t rc
;
899 const char *key
= "foo";
901 size_t string_length
;
903 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
905 string
= memcached_get(memc
, key
, strlen(key
),
906 &string_length
, &flags
, &rc
);
908 test_true(rc
== MEMCACHED_NOTFOUND
);
909 test_false(string_length
);
912 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
,
914 test_true(rc
== MEMCACHED_SUCCESS
);
916 string
= memcached_get(memc
, key
, strlen(key
),
917 &string_length
, &flags
, &rc
);
919 test_true(rc
== MEMCACHED_SUCCESS
);
920 test_true(string_length
== strlen(READ_THROUGH_VALUE
));
921 test_strcmp(READ_THROUGH_VALUE
, string
);
924 string
= memcached_get(memc
, key
, strlen(key
),
925 &string_length
, &flags
, &rc
);
927 test_true(rc
== MEMCACHED_SUCCESS
);
928 test_true(string_length
== strlen(READ_THROUGH_VALUE
));
929 test_true(!strcmp(READ_THROUGH_VALUE
, string
));
935 static memcached_return_t
delete_trigger(memcached_st
*ptr
,
939 (void)ptr
;(void)key_length
;
942 return MEMCACHED_SUCCESS
;
945 static test_return_t
delete_through(memcached_st
*memc
)
947 memcached_trigger_delete_key_fn callback
;
948 memcached_return_t rc
;
950 callback
= (memcached_trigger_delete_key_fn
)delete_trigger
;
952 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
953 test_true(rc
== MEMCACHED_SUCCESS
);
958 static test_return_t
get_test(memcached_st
*memc
)
960 memcached_return_t rc
;
961 const char *key
= "foo";
963 size_t string_length
;
966 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
967 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
969 string
= memcached_get(memc
, key
, strlen(key
),
970 &string_length
, &flags
, &rc
);
972 test_true(rc
== MEMCACHED_NOTFOUND
);
973 test_false(string_length
);
979 static test_return_t
get_test2(memcached_st
*memc
)
981 memcached_return_t rc
;
982 const char *key
= "foo";
983 const char *value
= "when we sanitize";
985 size_t string_length
;
988 rc
= memcached_set(memc
, key
, strlen(key
),
989 value
, strlen(value
),
990 (time_t)0, (uint32_t)0);
991 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
993 string
= memcached_get(memc
, key
, strlen(key
),
994 &string_length
, &flags
, &rc
);
997 test_true(rc
== MEMCACHED_SUCCESS
);
998 test_true(string_length
== strlen(value
));
999 test_true(!memcmp(string
, value
, string_length
));
1003 return TEST_SUCCESS
;
1006 static test_return_t
set_test2(memcached_st
*memc
)
1008 memcached_return_t rc
;
1009 const char *key
= "foo";
1010 const char *value
= "train in the brain";
1011 size_t value_length
= strlen(value
);
1014 for (x
= 0; x
< 10; x
++)
1016 rc
= memcached_set(memc
, key
, strlen(key
),
1017 value
, value_length
,
1018 (time_t)0, (uint32_t)0);
1019 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1022 return TEST_SUCCESS
;
1025 static test_return_t
set_test3(memcached_st
*memc
)
1027 memcached_return_t rc
;
1029 size_t value_length
= 8191;
1032 value
= (char*)malloc(value_length
);
1035 for (x
= 0; x
< value_length
; x
++)
1036 value
[x
] = (char) (x
% 127);
1038 /* The dump test relies on there being at least 32 items in memcached */
1039 for (x
= 0; x
< 32; x
++)
1043 snprintf(key
, sizeof(key
), "foo%u", x
);
1045 rc
= memcached_set(memc
, key
, strlen(key
),
1046 value
, value_length
,
1047 (time_t)0, (uint32_t)0);
1048 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1053 return TEST_SUCCESS
;
1056 static test_return_t
get_test3(memcached_st
*memc
)
1058 memcached_return_t rc
;
1059 const char *key
= "foo";
1061 size_t value_length
= 8191;
1063 size_t string_length
;
1067 value
= (char*)malloc(value_length
);
1070 for (x
= 0; x
< value_length
; x
++)
1071 value
[x
] = (char) (x
% 127);
1073 rc
= memcached_set(memc
, key
, strlen(key
),
1074 value
, value_length
,
1075 (time_t)0, (uint32_t)0);
1076 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1078 string
= memcached_get(memc
, key
, strlen(key
),
1079 &string_length
, &flags
, &rc
);
1081 test_true(rc
== MEMCACHED_SUCCESS
);
1083 test_true(string_length
== value_length
);
1084 test_true(!memcmp(string
, value
, string_length
));
1089 return TEST_SUCCESS
;
1092 static test_return_t
get_test4(memcached_st
*memc
)
1094 memcached_return_t rc
;
1095 const char *key
= "foo";
1097 size_t value_length
= 8191;
1099 size_t string_length
;
1103 value
= (char*)malloc(value_length
);
1106 for (x
= 0; x
< value_length
; x
++)
1107 value
[x
] = (char) (x
% 127);
1109 rc
= memcached_set(memc
, key
, strlen(key
),
1110 value
, value_length
,
1111 (time_t)0, (uint32_t)0);
1112 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1114 for (x
= 0; x
< 10; x
++)
1116 string
= memcached_get(memc
, key
, strlen(key
),
1117 &string_length
, &flags
, &rc
);
1119 test_true(rc
== MEMCACHED_SUCCESS
);
1121 test_true(string_length
== value_length
);
1122 test_true(!memcmp(string
, value
, string_length
));
1128 return TEST_SUCCESS
;
1132 * This test verifies that memcached_read_one_response doesn't try to
1133 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1134 * responses before you execute a storage command.
1136 static test_return_t
get_test5(memcached_st
*memc
)
1139 ** Request the same key twice, to ensure that we hash to the same server
1140 ** (so that we have multiple response values queued up) ;-)
1142 const char *keys
[]= { "key", "key" };
1143 size_t lengths
[]= { 3, 3 };
1147 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1148 keys
[0], lengths
[0], 0, 0);
1149 test_true(rc
== MEMCACHED_SUCCESS
);
1150 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1152 memcached_result_st results_obj
;
1153 memcached_result_st
*results
;
1154 results
=memcached_result_create(memc
, &results_obj
);
1156 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
1158 memcached_result_free(&results_obj
);
1160 /* Don't read out the second result, but issue a set instead.. */
1161 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
1162 test_true(rc
== MEMCACHED_SUCCESS
);
1164 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1165 &rlen
, &flags
, &rc
);
1166 test_true(val
== NULL
);
1167 test_true(rc
== MEMCACHED_NOTFOUND
);
1168 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1169 test_true(val
!= NULL
);
1170 test_true(rc
== MEMCACHED_SUCCESS
);
1173 return TEST_SUCCESS
;
1176 static test_return_t
mget_end(memcached_st
*memc
)
1178 const char *keys
[]= { "foo", "foo2" };
1179 size_t lengths
[]= { 3, 4 };
1180 const char *values
[]= { "fjord", "41" };
1182 memcached_return_t rc
;
1185 for (int i
= 0; i
< 2; i
++)
1187 rc
= memcached_set(memc
, keys
[i
], lengths
[i
], values
[i
], strlen(values
[i
]),
1188 (time_t)0, (uint32_t)0);
1189 test_true(rc
== MEMCACHED_SUCCESS
);
1193 size_t string_length
;
1196 // retrieve both via mget
1197 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1198 test_true(rc
== MEMCACHED_SUCCESS
);
1200 char key
[MEMCACHED_MAX_KEY
];
1203 // this should get both
1204 for (int i
= 0; i
< 2; i
++)
1206 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1208 test_true(rc
== MEMCACHED_SUCCESS
);
1210 if (key_length
== 4)
1212 test_true(string_length
== strlen(values
[val
]));
1213 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1217 // this should indicate end
1218 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1219 test_true(rc
== MEMCACHED_END
);
1222 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1223 test_true(rc
== MEMCACHED_SUCCESS
);
1225 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1226 test_true(key_length
== lengths
[0]);
1227 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1228 test_true(string_length
== strlen(values
[0]));
1229 test_true(strncmp(values
[0], string
, string_length
) == 0);
1230 test_true(rc
== MEMCACHED_SUCCESS
);
1233 // this should indicate end
1234 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1235 test_true(rc
== MEMCACHED_END
);
1237 return TEST_SUCCESS
;
1240 /* Do not copy the style of this code, I just access hosts to testthis function */
1241 static test_return_t
stats_servername_test(memcached_st
*memc
)
1243 memcached_return_t rc
;
1244 memcached_stat_st memc_stat
;
1245 memcached_server_instance_st instance
=
1246 memcached_server_instance_by_position(memc
, 0);
1248 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
1249 if (memcached_get_sasl_callbacks(memc
) != NULL
)
1250 return TEST_SKIPPED
;
1252 rc
= memcached_stat_servername(&memc_stat
, NULL
,
1253 memcached_server_name(instance
),
1254 memcached_server_port(instance
));
1256 return TEST_SUCCESS
;
1259 static test_return_t
increment_test(memcached_st
*memc
)
1261 uint64_t new_number
;
1262 memcached_return_t rc
;
1263 const char *key
= "number";
1264 const char *value
= "0";
1266 rc
= memcached_set(memc
, key
, strlen(key
),
1267 value
, strlen(value
),
1268 (time_t)0, (uint32_t)0);
1269 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1271 rc
= memcached_increment(memc
, key
, strlen(key
),
1273 test_true(rc
== MEMCACHED_SUCCESS
);
1274 test_true(new_number
== 1);
1276 rc
= memcached_increment(memc
, key
, strlen(key
),
1278 test_true(rc
== MEMCACHED_SUCCESS
);
1279 test_true(new_number
== 2);
1281 return TEST_SUCCESS
;
1284 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1286 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1288 uint64_t new_number
;
1289 memcached_return_t rc
;
1290 const char *key
= "number";
1291 uint64_t initial
= 0;
1293 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1294 1, initial
, 0, &new_number
);
1295 test_true(rc
== MEMCACHED_SUCCESS
);
1296 test_true(new_number
== initial
);
1298 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1299 1, initial
, 0, &new_number
);
1300 test_true(rc
== MEMCACHED_SUCCESS
);
1301 test_true(new_number
== (initial
+ 1));
1303 return TEST_SUCCESS
;
1306 static test_return_t
decrement_test(memcached_st
*memc
)
1308 uint64_t new_number
;
1309 memcached_return_t rc
;
1310 const char *key
= "number";
1311 const char *value
= "3";
1313 rc
= memcached_set(memc
, key
, strlen(key
),
1314 value
, strlen(value
),
1315 (time_t)0, (uint32_t)0);
1316 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1318 rc
= memcached_decrement(memc
, key
, strlen(key
),
1320 test_true(rc
== MEMCACHED_SUCCESS
);
1321 test_true(new_number
== 2);
1323 rc
= memcached_decrement(memc
, key
, strlen(key
),
1325 test_true(rc
== MEMCACHED_SUCCESS
);
1326 test_true(new_number
== 1);
1328 return TEST_SUCCESS
;
1331 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1333 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1335 uint64_t new_number
;
1336 memcached_return_t rc
;
1337 const char *key
= "number";
1338 uint64_t initial
= 3;
1340 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1341 1, initial
, 0, &new_number
);
1342 test_true(rc
== MEMCACHED_SUCCESS
);
1343 test_true(new_number
== initial
);
1345 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1346 1, initial
, 0, &new_number
);
1347 test_true(rc
== MEMCACHED_SUCCESS
);
1348 test_true(new_number
== (initial
- 1));
1350 return TEST_SUCCESS
;
1353 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1355 uint64_t new_number
;
1356 memcached_return_t rc
;
1357 const char *master_key
= "foo";
1358 const char *key
= "number";
1359 const char *value
= "0";
1361 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1363 value
, strlen(value
),
1364 (time_t)0, (uint32_t)0);
1365 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1367 rc
= memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1369 test_true(rc
== MEMCACHED_SUCCESS
);
1370 test_true(new_number
== 1);
1372 rc
= memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1374 test_true(rc
== MEMCACHED_SUCCESS
);
1375 test_true(new_number
== 2);
1377 return TEST_SUCCESS
;
1380 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1382 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1384 uint64_t new_number
;
1385 memcached_return_t rc
;
1386 const char *master_key
= "foo";
1387 const char *key
= "number";
1388 uint64_t initial
= 0;
1390 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1392 1, initial
, 0, &new_number
);
1393 test_true(rc
== MEMCACHED_SUCCESS
);
1394 test_true(new_number
== initial
);
1396 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1398 1, initial
, 0, &new_number
);
1399 test_true(rc
== MEMCACHED_SUCCESS
);
1400 test_true(new_number
== (initial
+ 1));
1402 return TEST_SUCCESS
;
1405 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1407 uint64_t new_number
;
1408 memcached_return_t rc
;
1409 const char *master_key
= "foo";
1410 const char *key
= "number";
1411 const char *value
= "3";
1413 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1415 value
, strlen(value
),
1416 (time_t)0, (uint32_t)0);
1417 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1419 rc
= memcached_decrement_by_key(memc
, master_key
, strlen(master_key
),
1422 test_true(rc
== MEMCACHED_SUCCESS
);
1423 test_true(new_number
== 2);
1425 rc
= memcached_decrement_by_key(memc
, master_key
, strlen(master_key
),
1428 test_true(rc
== MEMCACHED_SUCCESS
);
1429 test_true(new_number
== 1);
1431 return TEST_SUCCESS
;
1434 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1436 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1438 uint64_t new_number
;
1439 memcached_return_t rc
;
1440 const char *master_key
= "foo";
1441 const char *key
= "number";
1442 uint64_t initial
= 3;
1444 rc
= memcached_decrement_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1446 1, initial
, 0, &new_number
);
1447 test_true(rc
== MEMCACHED_SUCCESS
);
1448 test_true(new_number
== initial
);
1450 rc
= memcached_decrement_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1452 1, initial
, 0, &new_number
);
1453 test_true(rc
== MEMCACHED_SUCCESS
);
1454 test_true(new_number
== (initial
- 1));
1456 return TEST_SUCCESS
;
1459 static test_return_t
quit_test(memcached_st
*memc
)
1461 memcached_return_t rc
;
1462 const char *key
= "fudge";
1463 const char *value
= "sanford and sun";
1465 rc
= memcached_set(memc
, key
, strlen(key
),
1466 value
, strlen(value
),
1467 (time_t)10, (uint32_t)3);
1468 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1469 memcached_quit(memc
);
1471 rc
= memcached_set(memc
, key
, strlen(key
),
1472 value
, strlen(value
),
1473 (time_t)50, (uint32_t)9);
1474 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1476 return TEST_SUCCESS
;
1479 static test_return_t
mget_result_test(memcached_st
*memc
)
1481 memcached_return_t rc
;
1482 const char *keys
[]= {"fudge", "son", "food"};
1483 size_t key_length
[]= {5, 3, 4};
1486 memcached_result_st results_obj
;
1487 memcached_result_st
*results
;
1489 results
= memcached_result_create(memc
, &results_obj
);
1491 test_true(&results_obj
== results
);
1493 /* We need to empty the server before continueing test */
1494 rc
= memcached_flush(memc
, 0);
1495 test_true(rc
== MEMCACHED_SUCCESS
);
1497 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1498 test_true(rc
== MEMCACHED_SUCCESS
);
1500 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1505 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1506 test_true(!results
);
1507 test_true(rc
== MEMCACHED_END
);
1509 for (x
= 0; x
< 3; x
++)
1511 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1512 keys
[x
], key_length
[x
],
1513 (time_t)50, (uint32_t)9);
1514 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1517 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1518 test_true(rc
== MEMCACHED_SUCCESS
);
1520 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1523 test_true(&results_obj
== results
);
1524 test_true(rc
== MEMCACHED_SUCCESS
);
1525 test_true(memcached_result_key_length(results
) == memcached_result_length(results
));
1526 test_true(!memcmp(memcached_result_key_value(results
),
1527 memcached_result_value(results
),
1528 memcached_result_length(results
)));
1531 memcached_result_free(&results_obj
);
1533 return TEST_SUCCESS
;
1536 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1538 memcached_return_t rc
;
1539 const char *keys
[]= {"fudge", "son", "food"};
1540 size_t key_length
[]= {5, 3, 4};
1543 memcached_result_st
*results
;
1545 /* We need to empty the server before continueing test */
1546 rc
= memcached_flush(memc
, 0);
1547 test_true(rc
== MEMCACHED_SUCCESS
);
1549 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1550 test_true(rc
== MEMCACHED_SUCCESS
);
1552 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
1556 test_true(!results
);
1557 test_true(rc
== MEMCACHED_END
);
1559 for (x
= 0; x
< 3; x
++)
1561 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1562 keys
[x
], key_length
[x
],
1563 (time_t)50, (uint32_t)9);
1564 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1567 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1568 test_true(rc
== MEMCACHED_SUCCESS
);
1571 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1574 test_true(rc
== MEMCACHED_SUCCESS
);
1575 test_true(memcached_result_key_length(results
) == memcached_result_length(results
));
1576 test_true(!memcmp(memcached_result_key_value(results
),
1577 memcached_result_value(results
),
1578 memcached_result_length(results
)));
1579 memcached_result_free(results
);
1583 return TEST_SUCCESS
;
1586 /* Count the results */
1587 static memcached_return_t
callback_counter(const memcached_st
*ptr
,
1588 memcached_result_st
*result
,
1591 (void)ptr
; (void)result
;
1592 size_t *counter
= (size_t *)context
;
1594 *counter
= *counter
+ 1;
1596 return MEMCACHED_SUCCESS
;
1599 static test_return_t
mget_result_function(memcached_st
*memc
)
1601 memcached_return_t rc
;
1602 const char *keys
[]= {"fudge", "son", "food"};
1603 size_t key_length
[]= {5, 3, 4};
1606 memcached_execute_fn callbacks
[1];
1608 /* We need to empty the server before continueing test */
1609 rc
= memcached_flush(memc
, 0);
1610 for (x
= 0; x
< 3; x
++)
1612 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1613 keys
[x
], key_length
[x
],
1614 (time_t)50, (uint32_t)9);
1615 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1618 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1619 test_true(rc
== MEMCACHED_SUCCESS
);
1621 callbacks
[0]= &callback_counter
;
1623 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1625 test_true(counter
== 3);
1627 return TEST_SUCCESS
;
1630 static test_return_t
mget_test(memcached_st
*memc
)
1632 memcached_return_t rc
;
1633 const char *keys
[]= {"fudge", "son", "food"};
1634 size_t key_length
[]= {5, 3, 4};
1638 char return_key
[MEMCACHED_MAX_KEY
];
1639 size_t return_key_length
;
1641 size_t return_value_length
;
1643 /* We need to empty the server before continueing test */
1644 rc
= memcached_flush(memc
, 0);
1645 test_true(rc
== MEMCACHED_SUCCESS
);
1647 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1648 test_true(rc
== MEMCACHED_SUCCESS
);
1650 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1651 &return_value_length
, &flags
, &rc
)) != NULL
)
1653 test_true(return_value
);
1655 test_true(!return_value
);
1656 test_true(return_value_length
== 0);
1657 test_true(rc
== MEMCACHED_END
);
1659 for (x
= 0; x
< 3; x
++)
1661 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1662 keys
[x
], key_length
[x
],
1663 (time_t)50, (uint32_t)9);
1664 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1667 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1668 test_true(rc
== MEMCACHED_SUCCESS
);
1671 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1672 &return_value_length
, &flags
, &rc
)))
1674 test_true(return_value
);
1675 test_true(rc
== MEMCACHED_SUCCESS
);
1676 test_true(return_key_length
== return_value_length
);
1677 test_true(!memcmp(return_value
, return_key
, return_value_length
));
1682 return TEST_SUCCESS
;
1685 static test_return_t
mget_execute(memcached_st
*memc
)
1689 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1693 * I only want to hit _one_ server so I know the number of requests I'm
1694 * sending in the pipeline.
1696 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1697 memc
->number_of_hosts
= 1;
1699 size_t max_keys
= 20480;
1702 char **keys
= calloc(max_keys
, sizeof(char*));
1703 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
1705 /* First add all of the items.. */
1706 char blob
[1024] = {0};
1707 memcached_return_t rc
;
1709 for (size_t x
= 0; x
< max_keys
; ++x
)
1713 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1715 test_true(keys
[x
] != NULL
);
1716 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1717 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1720 /* Try to get all of them with a large multiget */
1722 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
1723 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1724 max_keys
, callbacks
, &counter
, 1);
1726 if (rc
== MEMCACHED_SUCCESS
)
1729 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1730 test_true(rc
== MEMCACHED_END
);
1732 /* Verify that we got all of the items */
1733 test_true(counter
== max_keys
);
1735 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1737 test_true(counter
== 0);
1741 test_fail("note: this test functions differently when in binary mode");
1744 /* Release all allocated resources */
1745 for (size_t x
= 0; x
< max_keys
; ++x
)
1752 memc
->number_of_hosts
= number_of_hosts
;
1753 return TEST_SUCCESS
;
1756 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1758 static test_return_t
key_setup(memcached_st
*memc
)
1762 if (pre_binary(memc
) != TEST_SUCCESS
)
1763 return TEST_SKIPPED
;
1765 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1767 return TEST_SUCCESS
;
1770 static test_return_t
key_teardown(memcached_st
*memc
)
1773 pairs_free(global_pairs
);
1775 return TEST_SUCCESS
;
1778 static test_return_t
block_add_regression(memcached_st
*memc
)
1780 /* First add all of the items.. */
1781 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1783 memcached_return_t rc
;
1784 char blob
[1024] = {0};
1786 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1787 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1790 return TEST_SUCCESS
;
1793 static test_return_t
binary_add_regression(memcached_st
*memc
)
1795 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1796 test_return_t rc
= block_add_regression(memc
);
1797 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1801 static test_return_t
get_stats_keys(memcached_st
*memc
)
1805 memcached_stat_st memc_stat
;
1806 memcached_return_t rc
;
1808 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1809 test_true(rc
== MEMCACHED_SUCCESS
);
1810 for (ptr
= stat_list
; *ptr
; ptr
++)
1815 return TEST_SUCCESS
;
1818 static test_return_t
version_string_test(memcached_st
*memc
)
1820 const char *version_string
;
1823 version_string
= memcached_lib_version();
1825 test_true(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1827 return TEST_SUCCESS
;
1830 static test_return_t
get_stats(memcached_st
*memc
)
1834 memcached_return_t rc
;
1835 memcached_stat_st
*memc_stat
;
1837 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1838 test_true(rc
== MEMCACHED_SUCCESS
);
1840 test_true(rc
== MEMCACHED_SUCCESS
);
1841 test_true(memc_stat
);
1843 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1845 stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1846 test_true(rc
== MEMCACHED_SUCCESS
);
1847 for (ptr
= stat_list
; *ptr
; ptr
++);
1852 memcached_stat_free(NULL
, memc_stat
);
1854 return TEST_SUCCESS
;
1857 static test_return_t
add_host_test(memcached_st
*memc
)
1860 memcached_server_st
*servers
;
1861 memcached_return_t rc
;
1862 char servername
[]= "0.example.com";
1864 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1866 test_true(1 == memcached_server_list_count(servers
));
1868 for (x
= 2; x
< 20; x
++)
1870 char buffer
[SMALL_STRING_LEN
];
1872 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1873 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1875 test_true(rc
== MEMCACHED_SUCCESS
);
1876 test_true(x
== memcached_server_list_count(servers
));
1879 rc
= memcached_server_push(memc
, servers
);
1880 test_true(rc
== MEMCACHED_SUCCESS
);
1881 rc
= memcached_server_push(memc
, servers
);
1882 test_true(rc
== MEMCACHED_SUCCESS
);
1884 memcached_server_list_free(servers
);
1886 return TEST_SUCCESS
;
1889 static memcached_return_t
clone_test_callback(memcached_st
*parent
, memcached_st
*memc_clone
)
1891 (void)parent
;(void)memc_clone
;
1892 return MEMCACHED_SUCCESS
;
1895 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
)
1898 return MEMCACHED_SUCCESS
;
1901 static test_return_t
callback_test(memcached_st
*memc
)
1903 /* Test User Data */
1907 memcached_return_t rc
;
1909 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1910 test_true(rc
== MEMCACHED_SUCCESS
);
1911 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1912 test_true(*test_ptr
== x
);
1915 /* Test Clone Callback */
1917 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1918 void *clone_cb_ptr
= *(void **)&clone_cb
;
1919 void *temp_function
= NULL
;
1920 memcached_return_t rc
;
1922 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1924 test_true(rc
== MEMCACHED_SUCCESS
);
1925 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1926 test_true(temp_function
== clone_cb_ptr
);
1929 /* Test Cleanup Callback */
1931 memcached_cleanup_fn cleanup_cb
=
1932 (memcached_cleanup_fn
)cleanup_test_callback
;
1933 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1934 void *temp_function
= NULL
;
1935 memcached_return_t rc
;
1937 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1939 test_true(rc
== MEMCACHED_SUCCESS
);
1940 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1941 test_true(temp_function
== cleanup_cb_ptr
);
1944 return TEST_SUCCESS
;
1947 /* We don't test the behavior itself, we test the switches */
1948 static test_return_t
behavior_test(memcached_st
*memc
)
1953 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1954 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1955 test_true(value
== 1);
1957 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1958 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1959 test_true(value
== 1);
1961 set
= MEMCACHED_HASH_MD5
;
1962 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1963 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1964 test_true(value
== MEMCACHED_HASH_MD5
);
1968 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1969 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1970 test_true(value
== 0);
1972 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1973 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1974 test_true(value
== 0);
1976 set
= MEMCACHED_HASH_DEFAULT
;
1977 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1978 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1979 test_true(value
== MEMCACHED_HASH_DEFAULT
);
1981 set
= MEMCACHED_HASH_CRC
;
1982 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1983 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1984 test_true(value
== MEMCACHED_HASH_CRC
);
1986 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1987 test_true(value
> 0);
1989 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1990 test_true(value
> 0);
1992 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
1993 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
1994 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
1996 return TEST_SUCCESS
;
1999 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2001 memcached_return_t rc
;
2004 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
2005 test_true(rc
== MEMCACHED_DEPRECATED
);
2007 // Platform dependent
2009 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2013 return TEST_SUCCESS
;
2017 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2019 memcached_return_t rc
;
2023 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, set
);
2024 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2026 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2028 if (rc
== MEMCACHED_SUCCESS
)
2030 test_true((bool)value
== set
);
2034 test_false((bool)value
== set
);
2037 return TEST_SUCCESS
;
2041 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2043 memcached_return_t rc
;
2047 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, set
);
2048 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2050 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2052 if (rc
== MEMCACHED_SUCCESS
)
2054 test_true((bool)value
== set
);
2058 test_false((bool)value
== set
);
2061 return TEST_SUCCESS
;
2064 static test_return_t
fetch_all_results(memcached_st
*memc
, size_t *keys_returned
)
2066 memcached_return_t rc
= MEMCACHED_SUCCESS
;
2067 char return_key
[MEMCACHED_MAX_KEY
];
2068 size_t return_key_length
;
2070 size_t return_value_length
;
2075 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2076 &return_value_length
, &flags
, &rc
)))
2078 test_true(return_value
);
2079 test_true(rc
== MEMCACHED_SUCCESS
);
2081 *keys_returned
= *keys_returned
+1;
2084 test_true_got(rc
== MEMCACHED_END
|| rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
2086 return TEST_SUCCESS
;
2089 /* Test case provided by Cal Haldenbrand */
2090 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2092 unsigned int setter
= 1;
2094 unsigned long long total
= 0;
2097 char randomstuff
[6 * 1024];
2098 memcached_return_t rc
;
2100 memset(randomstuff
, 0, 6 * 1024);
2102 /* We just keep looking at the same values over and over */
2105 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2106 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2110 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2114 size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2115 memset(randomstuff
, 0, 6 * 1024);
2116 test_true(size
< 6 * 1024); /* Being safe here */
2118 for (j
= 0 ; j
< size
;j
++)
2119 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2122 snprintf(key
, sizeof(key
), "%u", x
);
2123 rc
= memcached_set(memc
, key
, strlen(key
),
2124 randomstuff
, strlen(randomstuff
), 10, 0);
2125 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2126 /* If we fail, lets try again */
2127 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
2128 rc
= memcached_set(memc
, key
, strlen(key
),
2129 randomstuff
, strlen(randomstuff
), 10, 0);
2130 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2133 return TEST_SUCCESS
;
2136 /* Test case provided by Cal Haldenbrand */
2137 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2139 unsigned int setter
;
2143 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2144 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2146 setter
= 20 * 1024576;
2147 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2148 setter
= 20 * 1024576;
2149 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2150 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2151 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2153 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2156 for (uint32_t x
= 0, errors
= 0; total
< 24576 ; x
++)
2158 memcached_return_t rc
= MEMCACHED_SUCCESS
;
2159 char buffer
[SMALL_STRING_LEN
];
2164 memset(buffer
, 0, SMALL_STRING_LEN
);
2166 snprintf(buffer
, sizeof(buffer
), "%u", x
);
2167 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
2168 &val_len
, &flags
, &rc
);
2169 if (rc
!= MEMCACHED_SUCCESS
)
2171 if (rc
== MEMCACHED_NOTFOUND
)
2185 return TEST_SUCCESS
;
2188 /* Do a large mget() over all the keys we think exist */
2189 #define KEY_COUNT 3000 // * 1024576
2190 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2192 memcached_return_t rc
;
2193 unsigned int setter
;
2196 size_t key_lengths
[KEY_COUNT
];
2199 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2200 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2202 setter
= 20 * 1024576;
2203 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2204 setter
= 20 * 1024576;
2205 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2206 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2207 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2210 keys
= calloc(KEY_COUNT
, sizeof(char *));
2212 for (x
= 0; x
< KEY_COUNT
; x
++)
2216 snprintf(buffer
, 30, "%u", x
);
2217 keys
[x
]= strdup(buffer
);
2218 key_lengths
[x
]= strlen(keys
[x
]);
2221 rc
= memcached_mget(memc
, (const char **)keys
, key_lengths
, KEY_COUNT
);
2222 test_true(rc
== MEMCACHED_SUCCESS
);
2224 size_t keys_returned
;
2225 test_true(fetch_all_results(memc
, &keys_returned
) == TEST_SUCCESS
);
2227 for (x
= 0; x
< KEY_COUNT
; x
++)
2231 return TEST_SUCCESS
;
2234 /* Make sure we behave properly if server list has no values */
2235 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2237 memcached_return_t rc
;
2238 const char *keys
[]= {"fudge", "son", "food"};
2239 size_t key_length
[]= {5, 3, 4};
2242 char return_key
[MEMCACHED_MAX_KEY
];
2243 size_t return_key_length
;
2245 size_t return_value_length
;
2247 /* Here we free everything before running a bunch of mget tests */
2248 memcached_servers_reset(memc
);
2251 /* We need to empty the server before continueing test */
2252 rc
= memcached_flush(memc
, 0);
2253 test_true(rc
== MEMCACHED_NO_SERVERS
);
2255 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2256 test_true(rc
== MEMCACHED_NO_SERVERS
);
2258 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2259 &return_value_length
, &flags
, &rc
)) != NULL
)
2261 test_true(return_value
);
2263 test_true(!return_value
);
2264 test_true(return_value_length
== 0);
2265 test_true(rc
== MEMCACHED_NO_SERVERS
);
2267 for (x
= 0; x
< 3; x
++)
2269 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2270 keys
[x
], key_length
[x
],
2271 (time_t)50, (uint32_t)9);
2272 test_true(rc
== MEMCACHED_NO_SERVERS
);
2275 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2276 test_true(rc
== MEMCACHED_NO_SERVERS
);
2279 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2280 &return_value_length
, &flags
, &rc
)))
2282 test_true(return_value
);
2283 test_true(rc
== MEMCACHED_SUCCESS
);
2284 test_true(return_key_length
== return_value_length
);
2285 test_true(!memcmp(return_value
, return_key
, return_value_length
));
2290 return TEST_SUCCESS
;
2293 #define VALUE_SIZE_BUG5 1048064
2294 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2296 memcached_return_t rc
;
2297 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2298 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2299 char return_key
[MEMCACHED_MAX_KEY
];
2300 size_t return_key_length
;
2302 size_t value_length
;
2306 char insert_data
[VALUE_SIZE_BUG5
];
2308 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2309 insert_data
[x
]= (signed char)rand();
2311 memcached_flush(memc
, 0);
2312 value
= memcached_get(memc
, keys
[0], key_length
[0],
2313 &value_length
, &flags
, &rc
);
2314 test_true(value
== NULL
);
2315 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2318 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2319 &value_length
, &flags
, &rc
)))
2321 test_true(count
== 0);
2323 for (x
= 0; x
< 4; x
++)
2325 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2326 insert_data
, VALUE_SIZE_BUG5
,
2327 (time_t)0, (uint32_t)0);
2328 test_true(rc
== MEMCACHED_SUCCESS
);
2331 for (x
= 0; x
< 10; x
++)
2333 value
= memcached_get(memc
, keys
[0], key_length
[0],
2334 &value_length
, &flags
, &rc
);
2338 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2340 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2341 &value_length
, &flags
, &rc
)))
2346 test_true(count
== 4);
2349 return TEST_SUCCESS
;
2352 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2354 memcached_return_t rc
;
2355 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2356 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2357 char return_key
[MEMCACHED_MAX_KEY
];
2358 size_t return_key_length
;
2360 size_t value_length
;
2364 char insert_data
[VALUE_SIZE_BUG5
];
2366 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2367 insert_data
[x
]= (signed char)rand();
2369 memcached_flush(memc
, 0);
2370 value
= memcached_get(memc
, keys
[0], key_length
[0],
2371 &value_length
, &flags
, &rc
);
2372 test_true(value
== NULL
);
2373 test_true(rc
== MEMCACHED_NOTFOUND
);
2374 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2375 test_true(rc
== MEMCACHED_SUCCESS
);
2378 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2379 &value_length
, &flags
, &rc
)))
2381 test_true(count
== 0);
2382 test_true(rc
== MEMCACHED_END
);
2384 for (x
= 0; x
< 4; x
++)
2386 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2387 insert_data
, VALUE_SIZE_BUG5
,
2388 (time_t)0, (uint32_t)0);
2389 test_true(rc
== MEMCACHED_SUCCESS
);
2392 for (x
= 0; x
< 2; x
++)
2394 value
= memcached_get(memc
, keys
[0], key_length
[0],
2395 &value_length
, &flags
, &rc
);
2399 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2400 test_true(rc
== MEMCACHED_SUCCESS
);
2402 /* We test for purge of partial complete fetches */
2403 for (count
= 3; count
; count
--)
2405 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2406 &value_length
, &flags
, &rc
);
2407 test_true(rc
== MEMCACHED_SUCCESS
);
2408 test_true(!(memcmp(value
, insert_data
, value_length
)));
2409 test_true(value_length
);
2414 return TEST_SUCCESS
;
2417 static test_return_t
user_supplied_bug8(memcached_st
*memc
)
2419 memcached_return_t rc
;
2421 memcached_st
*memc_clone
;
2423 memcached_server_st
*servers
;
2424 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";
2427 servers
= memcached_servers_parse(server_list
);
2430 mine
= memcached_create(NULL
);
2431 rc
= memcached_server_push(mine
, servers
);
2432 test_true(rc
== MEMCACHED_SUCCESS
);
2433 memcached_server_list_free(servers
);
2436 memc_clone
= memcached_clone(NULL
, mine
);
2438 memcached_quit(mine
);
2439 memcached_quit(memc_clone
);
2442 memcached_free(mine
);
2443 memcached_free(memc_clone
);
2445 return TEST_SUCCESS
;
2448 /* Test flag store/retrieve */
2449 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2451 memcached_return_t rc
;
2452 const char *keys
= "036790384900";
2453 size_t key_length
= strlen(keys
);
2454 char return_key
[MEMCACHED_MAX_KEY
];
2455 size_t return_key_length
;
2457 size_t value_length
;
2460 char insert_data
[VALUE_SIZE_BUG5
];
2462 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2463 insert_data
[x
]= (signed char)rand();
2465 memcached_flush(memc
, 0);
2468 rc
= memcached_set(memc
, keys
, key_length
,
2469 insert_data
, VALUE_SIZE_BUG5
,
2471 test_true(rc
== MEMCACHED_SUCCESS
);
2474 value
= memcached_get(memc
, keys
, key_length
,
2475 &value_length
, &flags
, &rc
);
2476 test_true(flags
== 245);
2480 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2483 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2484 &value_length
, &flags
, &rc
);
2485 test_true(flags
== 245);
2490 return TEST_SUCCESS
;
2493 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2495 memcached_return_t rc
;
2496 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2497 size_t key_length
[3];
2502 char return_key
[MEMCACHED_MAX_KEY
];
2503 size_t return_key_length
;
2505 size_t return_value_length
;
2508 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2509 key_length
[1]= strlen("fudge&*@#");
2510 key_length
[2]= strlen("for^#@&$not");
2513 for (x
= 0; x
< 3; x
++)
2515 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2516 keys
[x
], key_length
[x
],
2517 (time_t)50, (uint32_t)9);
2518 test_true(rc
== MEMCACHED_SUCCESS
);
2521 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2522 test_true(rc
== MEMCACHED_SUCCESS
);
2524 /* We need to empty the server before continueing test */
2525 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2526 &return_value_length
, &flags
, &rc
)) != NULL
)
2528 test_true(return_value
);
2532 test_true(count
== 3);
2534 return TEST_SUCCESS
;
2537 /* We are testing with aggressive timeout to get failures */
2538 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2540 const char *key
= "foo";
2542 size_t value_length
= 512;
2545 memcached_return_t rc
;
2546 unsigned int set
= 1;
2547 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2550 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2551 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2553 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2556 value
= (char*)malloc(value_length
* sizeof(char));
2558 for (x
= 0; x
< value_length
; x
++)
2559 value
[x
]= (char) (x
% 127);
2561 for (x
= 1; x
<= 100000; ++x
)
2563 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2565 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2566 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2568 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2573 memcached_free(mclone
);
2575 return TEST_SUCCESS
;
2579 We are looking failures in the async protocol
2581 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2583 const char *key
= "foo";
2585 size_t value_length
= 512;
2588 memcached_return_t rc
;
2589 unsigned int set
= 1;
2591 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2593 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2594 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2596 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2599 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2601 test_true(timeout
== -1);
2603 value
= (char*)malloc(value_length
* sizeof(char));
2605 for (x
= 0; x
< value_length
; x
++)
2606 value
[x
]= (char) (x
% 127);
2608 for (x
= 1; x
<= 100000; ++x
)
2610 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2614 memcached_free(mclone
);
2616 return TEST_SUCCESS
;
2620 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2622 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2624 memcached_return_t rc
;
2626 size_t value_length
;
2628 uint64_t number_value
;
2630 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2631 &value_length
, &flags
, &rc
);
2632 test_true(value
== NULL
);
2633 test_true(rc
== MEMCACHED_NOTFOUND
);
2635 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2638 test_true(value
== NULL
);
2639 /* The binary protocol will set the key if it doesn't exist */
2640 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2642 test_true(rc
== MEMCACHED_SUCCESS
);
2646 test_true(rc
== MEMCACHED_NOTFOUND
);
2649 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2651 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2652 &value_length
, &flags
, &rc
);
2654 test_true(rc
== MEMCACHED_SUCCESS
);
2657 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2659 test_true(number_value
== 2);
2660 test_true(rc
== MEMCACHED_SUCCESS
);
2662 return TEST_SUCCESS
;
2666 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2667 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2669 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2671 char key
[] = "key34567890";
2673 memcached_return_t rc
;
2674 size_t overflowSize
;
2676 char commandFirst
[]= "set key34567890 0 0 ";
2677 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2678 size_t commandLength
;
2681 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2683 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2685 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2687 overflow
= malloc(testSize
);
2688 test_true(overflow
!= NULL
);
2690 memset(overflow
, 'x', testSize
);
2691 rc
= memcached_set(memc
, key
, strlen(key
),
2692 overflow
, testSize
, 0, 0);
2693 test_true(rc
== MEMCACHED_SUCCESS
);
2697 return TEST_SUCCESS
;
2702 Test values of many different sizes
2703 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2704 set key34567890 0 0 8169 \r\n
2705 is sent followed by buffer of size 8169, followed by 8169
2707 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2710 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2711 memcached_return_t rc
;
2712 const char *key
= "foo";
2714 size_t value_length
= 18000;
2716 size_t string_length
;
2719 size_t current_length
;
2721 value
= (char*)malloc(value_length
);
2724 for (x
= 0; x
< value_length
; x
++)
2725 value
[x
] = (char) (x
% 127);
2727 for (current_length
= 0; current_length
< value_length
; current_length
++)
2729 rc
= memcached_set(memc
, key
, strlen(key
),
2730 value
, current_length
,
2731 (time_t)0, (uint32_t)0);
2732 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2734 string
= memcached_get(memc
, key
, strlen(key
),
2735 &string_length
, &flags
, &rc
);
2737 test_true(rc
== MEMCACHED_SUCCESS
);
2738 test_true(string_length
== current_length
);
2739 test_true(!memcmp(string
, value
, string_length
));
2746 return TEST_SUCCESS
;
2750 Look for zero length value problems
2752 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2755 memcached_return_t rc
;
2756 const char *key
= "mykey";
2761 for (x
= 0; x
< 2; x
++)
2763 rc
= memcached_set(memc
, key
, strlen(key
),
2765 (time_t)0, (uint32_t)0);
2767 test_true(rc
== MEMCACHED_SUCCESS
);
2769 value
= memcached_get(memc
, key
, strlen(key
),
2770 &length
, &flags
, &rc
);
2772 test_true(rc
== MEMCACHED_SUCCESS
);
2773 test_true(value
== NULL
);
2774 test_true(length
== 0);
2775 test_true(flags
== 0);
2777 value
= memcached_get(memc
, key
, strlen(key
),
2778 &length
, &flags
, &rc
);
2780 test_true(rc
== MEMCACHED_SUCCESS
);
2781 test_true(value
== NULL
);
2782 test_true(length
== 0);
2783 test_true(flags
== 0);
2786 return TEST_SUCCESS
;
2789 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2790 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2792 memcached_return_t rc
;
2793 const char *key
= "mykey";
2798 rc
= memcached_set(memc
, key
, strlen(key
),
2800 (time_t)0, UINT32_MAX
);
2802 test_true(rc
== MEMCACHED_SUCCESS
);
2804 value
= memcached_get(memc
, key
, strlen(key
),
2805 &length
, &flags
, &rc
);
2807 test_true(rc
== MEMCACHED_SUCCESS
);
2808 test_true(value
== NULL
);
2809 test_true(length
== 0);
2810 test_true(flags
== UINT32_MAX
);
2812 return TEST_SUCCESS
;
2815 #if !defined(__sun) && !defined(__OpenBSD__)
2816 /* Check the validity of chinese key*/
2817 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2819 memcached_return_t rc
;
2820 const char *key
= "豆瓣";
2821 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2826 rc
= memcached_set(memc
, key
, strlen(key
),
2827 value
, strlen(value
),
2830 test_true(rc
== MEMCACHED_SUCCESS
);
2832 value2
= memcached_get(memc
, key
, strlen(key
),
2833 &length
, &flags
, &rc
);
2835 test_true(length
==strlen(value
));
2836 test_true(rc
== MEMCACHED_SUCCESS
);
2837 test_true(memcmp(value
, value2
, length
)==0);
2840 return TEST_SUCCESS
;
2848 static test_return_t
user_supplied_bug19(memcached_st
*not_used
)
2851 const memcached_server_st
*server
;
2852 memcached_return_t res
;
2856 memc
= memcached_create(NULL
);
2857 memcached_server_add_with_weight(memc
, "localhost", 11311, 100);
2858 memcached_server_add_with_weight(memc
, "localhost", 11312, 100);
2860 server
= memcached_server_by_key(memc
, "a", 1, &res
);
2862 memcached_free(memc
);
2864 return TEST_SUCCESS
;
2867 /* CAS test from Andei */
2868 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2870 memcached_return_t status
;
2871 memcached_result_st
*result
, result_obj
;
2872 const char *key
= "abc";
2873 size_t key_len
= strlen("abc");
2874 const char *value
= "foobar";
2875 size_t value_len
= strlen(value
);
2877 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2879 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2880 test_true(status
== MEMCACHED_SUCCESS
);
2882 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2883 test_true(status
== MEMCACHED_SUCCESS
);
2885 result
= memcached_result_create(memc
, &result_obj
);
2888 memcached_result_create(memc
, &result_obj
);
2889 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2892 test_true(status
== MEMCACHED_SUCCESS
);
2894 memcached_result_free(result
);
2896 return TEST_SUCCESS
;
2899 #include "ketama_test_cases.h"
2900 static test_return_t
user_supplied_bug18(memcached_st
*trash
)
2902 memcached_return_t rc
;
2905 memcached_server_st
*server_pool
;
2910 memc
= memcached_create(NULL
);
2913 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2914 test_true(rc
== MEMCACHED_SUCCESS
);
2916 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2917 test_true(value
== 1);
2919 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2920 test_true(rc
== MEMCACHED_SUCCESS
);
2922 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2923 test_true(value
== MEMCACHED_HASH_MD5
);
2925 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");
2926 memcached_server_push(memc
, server_pool
);
2928 /* verify that the server list was parsed okay. */
2929 test_true(memcached_server_count(memc
) == 8);
2930 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2931 test_true(server_pool
[0].port
== 11211);
2932 test_true(server_pool
[0].weight
== 600);
2933 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2934 test_true(server_pool
[2].port
== 11211);
2935 test_true(server_pool
[2].weight
== 200);
2936 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2937 test_true(server_pool
[7].port
== 11211);
2938 test_true(server_pool
[7].weight
== 100);
2940 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2941 * us test the boundary wraparound.
2943 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
2945 /* verify the standard ketama set. */
2946 for (x
= 0; x
< 99; x
++)
2948 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2950 memcached_server_instance_st instance
=
2951 memcached_server_instance_by_position(memc
, server_idx
);
2953 const char *hostname
= memcached_server_name(instance
);
2954 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
2957 memcached_server_list_free(server_pool
);
2958 memcached_free(memc
);
2960 return TEST_SUCCESS
;
2963 /* Large mget() of missing keys with binary proto
2965 * If many binary quiet commands (such as getq's in an mget) fill the output
2966 * buffer and the server chooses not to respond, memcached_flush hangs. See
2967 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2970 /* sighandler_t function that always asserts false */
2971 static void fail(int unused
)
2978 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2983 return TEST_SKIPPED
;
2985 memcached_return_t rc
;
2988 size_t* key_lengths
;
2989 void (*oldalarm
)(int);
2990 memcached_st
*memc_clone
;
2992 memc_clone
= memcached_clone(NULL
, memc
);
2993 test_true(memc_clone
);
2995 /* only binproto uses getq for mget */
2996 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2998 /* empty the cache to ensure misses (hence non-responses) */
2999 rc
= memcached_flush(memc_clone
, 0);
3000 test_true(rc
== MEMCACHED_SUCCESS
);
3002 key_lengths
= calloc(key_count
, sizeof(size_t));
3003 keys
= calloc(key_count
, sizeof(char *));
3005 for (x
= 0; x
< key_count
; x
++)
3009 snprintf(buffer
, 30, "%u", x
);
3010 keys
[x
]= strdup(buffer
);
3011 key_lengths
[x
]= strlen(keys
[x
]);
3014 oldalarm
= signal(SIGALRM
, fail
);
3017 rc
= memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
);
3018 test_true(rc
== MEMCACHED_SUCCESS
);
3021 signal(SIGALRM
, oldalarm
);
3023 size_t keys_returned
;
3024 test_true(fetch_all_results(memc
, &keys_returned
) == TEST_SUCCESS
);
3026 for (x
= 0; x
< key_count
; x
++)
3031 memcached_free(memc_clone
);
3033 return TEST_SUCCESS
;
3037 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3039 test_return_t test_rc
;
3040 test_rc
= pre_binary(memc
);
3042 if (test_rc
!= TEST_SUCCESS
)
3047 /* should work as of r580 */
3048 rc
= _user_supplied_bug21(memc
, 10);
3049 test_true(rc
== TEST_SUCCESS
);
3051 /* should fail as of r580 */
3052 rc
= _user_supplied_bug21(memc
, 1000);
3053 test_true(rc
== TEST_SUCCESS
);
3055 return TEST_SUCCESS
;
3058 static test_return_t
auto_eject_hosts(memcached_st
*trash
)
3061 memcached_server_instance_st instance
;
3063 memcached_return_t rc
;
3064 memcached_st
*memc
= memcached_create(NULL
);
3067 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3068 test_true(rc
== MEMCACHED_SUCCESS
);
3070 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3071 test_true(value
== 1);
3073 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3074 test_true(rc
== MEMCACHED_SUCCESS
);
3076 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3077 test_true(value
== MEMCACHED_HASH_MD5
);
3079 /* server should be removed when in delay */
3080 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
3081 test_true(rc
== MEMCACHED_SUCCESS
);
3083 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
3084 test_true(value
== 1);
3086 memcached_server_st
*server_pool
;
3087 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");
3088 memcached_server_push(memc
, server_pool
);
3090 /* verify that the server list was parsed okay. */
3091 test_true(memcached_server_count(memc
) == 8);
3092 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
3093 test_true(server_pool
[0].port
== 11211);
3094 test_true(server_pool
[0].weight
== 600);
3095 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
3096 test_true(server_pool
[2].port
== 11211);
3097 test_true(server_pool
[2].weight
== 200);
3098 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
3099 test_true(server_pool
[7].port
== 11211);
3100 test_true(server_pool
[7].weight
== 100);
3102 instance
= memcached_server_instance_by_position(memc
, 2);
3103 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) + 15;
3104 memc
->ketama
.next_distribution_rebuild
= time(NULL
) - 1;
3107 This would not work if there were only two hosts.
3109 for (size_t x
= 0; x
< 99; x
++)
3111 memcached_autoeject(memc
);
3112 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3113 test_true(server_idx
!= 2);
3116 /* and re-added when it's back. */
3117 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) - 1;
3118 memc
->ketama
.next_distribution_rebuild
= time(NULL
) - 1;
3119 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
,
3120 memc
->distribution
);
3121 for (size_t x
= 0; x
< 99; x
++)
3123 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3124 // We re-use instance from above.
3126 memcached_server_instance_by_position(memc
, server_idx
);
3127 const char *hostname
= memcached_server_name(instance
);
3128 test_true(strcmp(hostname
, ketama_test_cases
[x
].server
) == 0);
3131 memcached_server_list_free(server_pool
);
3132 memcached_free(memc
);
3134 return TEST_SUCCESS
;
3137 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
3141 memcached_return_t rc
;
3142 memcached_st
*memc
= memcached_create(NULL
);
3146 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3147 test_true(rc
== MEMCACHED_SUCCESS
);
3149 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3150 test_true(value
== 1);
3152 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3153 test_true(rc
== MEMCACHED_SUCCESS
);
3155 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3156 test_true(value
== MEMCACHED_HASH_MD5
);
3159 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3161 memcached_server_st
*server_pool
;
3162 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");
3163 memcached_server_push(memc
, server_pool
);
3165 // @todo this needs to be refactored to actually test something.
3168 if ((fp
= fopen("ketama_keys.txt", "w")))
3172 printf("cannot write to file ketama_keys.txt");
3173 return TEST_FAILURE
;
3176 for (int x
= 0; x
< 10000; x
++)
3179 snprintf(key
, sizeof(key
), "%d", x
);
3181 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3182 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3183 in_port_t port
= memc
->hosts
[server_idx
].port
;
3184 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3185 memcached_server_instance_st instance
=
3186 memcached_server_instance_by_position(memc
, host_index
);
3190 memcached_server_list_free(server_pool
);
3191 memcached_free(memc
);
3193 return TEST_SUCCESS
;
3197 static test_return_t
result_static(memcached_st
*memc
)
3199 memcached_result_st result
;
3200 memcached_result_st
*result_ptr
;
3202 result_ptr
= memcached_result_create(memc
, &result
);
3203 test_true(result
.options
.is_allocated
== false);
3204 test_true(memcached_is_initialized(&result
) == true);
3205 test_true(result_ptr
);
3206 test_true(result_ptr
== &result
);
3208 memcached_result_free(&result
);
3210 test_true(result
.options
.is_allocated
== false);
3211 test_true(memcached_is_initialized(&result
) == false);
3213 return TEST_SUCCESS
;
3216 static test_return_t
result_alloc(memcached_st
*memc
)
3218 memcached_result_st
*result_ptr
;
3220 result_ptr
= memcached_result_create(memc
, NULL
);
3221 test_true(result_ptr
);
3222 test_true(result_ptr
->options
.is_allocated
== true);
3223 test_true(memcached_is_initialized(result_ptr
) == true);
3224 memcached_result_free(result_ptr
);
3226 return TEST_SUCCESS
;
3229 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3232 pairs_free(global_pairs
);
3234 return TEST_SUCCESS
;
3237 static test_return_t
generate_pairs(memcached_st
*memc
)
3240 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3241 global_count
= GLOBAL_COUNT
;
3243 for (size_t x
= 0; x
< global_count
; x
++)
3245 global_keys
[x
]= global_pairs
[x
].key
;
3246 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3249 return TEST_SUCCESS
;
3252 static test_return_t
generate_large_pairs(memcached_st
*memc
)
3255 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3256 global_count
= GLOBAL2_COUNT
;
3258 for (size_t x
= 0; x
< global_count
; x
++)
3260 global_keys
[x
]= global_pairs
[x
].key
;
3261 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3264 return TEST_SUCCESS
;
3267 static test_return_t
generate_data(memcached_st
*memc
)
3269 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3271 test_true(check_execute
== global_count
);
3273 return TEST_SUCCESS
;
3276 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3278 memcached_stat_st
*stat_p
;
3279 memcached_return_t rc
;
3280 uint32_t host_index
= 0;
3281 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3283 test_true(check_execute
== global_count
);
3285 //TODO: hosts used size stats
3286 stat_p
= memcached_stat(memc
, NULL
, &rc
);
3289 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3291 /* This test was changes so that "make test" would work properlly */
3293 memcached_server_instance_st instance
=
3294 memcached_server_instance_by_position(memc
, host_index
);
3296 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3298 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3301 memcached_stat_free(NULL
, stat_p
);
3303 return TEST_SUCCESS
;
3305 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3310 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3311 generate_data(memc
);
3313 return TEST_SUCCESS
;
3316 static test_return_t
get_read_count(memcached_st
*memc
)
3318 memcached_return_t rc
;
3319 memcached_st
*memc_clone
;
3321 memc_clone
= memcached_clone(NULL
, memc
);
3322 test_true(memc_clone
);
3324 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3328 size_t return_value_length
;
3332 for (size_t x
= count
= 0; x
< global_count
; x
++)
3334 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3335 &return_value_length
, &flags
, &rc
);
3336 if (rc
== MEMCACHED_SUCCESS
)
3345 memcached_free(memc_clone
);
3347 return TEST_SUCCESS
;
3350 static test_return_t
get_read(memcached_st
*memc
)
3352 memcached_return_t rc
;
3356 size_t return_value_length
;
3359 for (size_t x
= 0; x
< global_count
; x
++)
3361 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3362 &return_value_length
, &flags
, &rc
);
3364 test_true(return_value);
3365 test_true(rc == MEMCACHED_SUCCESS);
3367 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3372 return TEST_SUCCESS
;
3375 static test_return_t
mget_read(memcached_st
*memc
)
3377 memcached_return_t rc
;
3379 if (! libmemcached_util_version_check(memc
, 1, 4, 4))
3380 return TEST_SKIPPED
;
3382 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3384 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
3386 // Go fetch the keys and test to see if all of them were returned
3388 size_t keys_returned
;
3389 test_true(fetch_all_results(memc
, &keys_returned
) == TEST_SUCCESS
);
3391 snprintf(buffer
, sizeof(buffer
), "%lu", (unsigned long)keys_returned
);
3392 test_true_got(global_count
== keys_returned
, buffer
);
3396 return TEST_SUCCESS
;
3399 static test_return_t
mget_read_result(memcached_st
*memc
)
3401 memcached_return_t rc
;
3403 if (! libmemcached_util_version_check(memc
, 1, 4, 4))
3404 return TEST_SKIPPED
;
3406 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3408 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
3410 /* Turn this into a help function */
3412 memcached_result_st results_obj
;
3413 memcached_result_st
*results
;
3415 results
= memcached_result_create(memc
, &results_obj
);
3417 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3420 test_true(rc
== MEMCACHED_SUCCESS
);
3423 memcached_result_free(&results_obj
);
3426 return TEST_SUCCESS
;
3429 static test_return_t
mget_read_function(memcached_st
*memc
)
3431 memcached_return_t rc
;
3433 memcached_execute_fn callbacks
[1];
3435 if (! libmemcached_util_version_check(memc
, 1, 4, 4))
3436 return TEST_SKIPPED
;
3438 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3440 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
3442 callbacks
[0]= &callback_counter
;
3444 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
3446 return TEST_SUCCESS
;
3449 static test_return_t
delete_generate(memcached_st
*memc
)
3451 for (size_t x
= 0; x
< global_count
; x
++)
3453 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3456 return TEST_SUCCESS
;
3459 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3464 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3466 for (size_t x
= 0; x
< global_count
; x
++)
3468 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3471 return TEST_SUCCESS
;
3474 static test_return_t
add_host_test1(memcached_st
*memc
)
3476 memcached_return_t rc
;
3477 char servername
[]= "0.example.com";
3478 memcached_server_st
*servers
;
3480 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3482 test_true(1 == memcached_server_list_count(servers
));
3484 for (size_t x
= 2; x
< 20; x
++)
3486 char buffer
[SMALL_STRING_LEN
];
3488 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3489 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3491 test_true(rc
== MEMCACHED_SUCCESS
);
3492 test_true(x
== memcached_server_list_count(servers
));
3495 rc
= memcached_server_push(memc
, servers
);
3496 test_true(rc
== MEMCACHED_SUCCESS
);
3497 rc
= memcached_server_push(memc
, servers
);
3498 test_true(rc
== MEMCACHED_SUCCESS
);
3500 memcached_server_list_free(servers
);
3502 return TEST_SUCCESS
;
3505 static test_return_t
pre_nonblock(memcached_st
*memc
)
3507 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3509 return TEST_SUCCESS
;
3512 static test_return_t
pre_cork(memcached_st
*memc
)
3514 memcached_return_t rc
;
3517 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
3520 return TEST_SKIPPED
;
3523 if (rc
== MEMCACHED_SUCCESS
)
3524 return TEST_SUCCESS
;
3526 return TEST_SKIPPED
;
3529 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3536 return TEST_SKIPPED
;
3539 if (rc
!= TEST_SUCCESS
)
3542 return pre_nonblock(memc
);
3545 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3547 memcached_return_t rc
= MEMCACHED_FAILURE
;
3548 memcached_st
*memc_clone
;
3550 memc_clone
= memcached_clone(NULL
, memc
);
3551 test_true(memc_clone
);
3552 // The memcached_version needs to be done on a clone, because the server
3553 // will not toggle protocol on an connection.
3554 memcached_version(memc_clone
);
3556 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3558 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3559 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3560 test_true(rc
== MEMCACHED_SUCCESS
);
3561 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3565 return TEST_SKIPPED
;
3568 memcached_free(memc_clone
);
3570 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3573 static test_return_t
pre_murmur(memcached_st
*memc
)
3575 #ifdef HAVE_MURMUR_HASH
3576 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3577 return TEST_SUCCESS
;
3580 return TEST_SKIPPED
;
3584 static test_return_t
pre_jenkins(memcached_st
*memc
)
3586 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3588 return TEST_SUCCESS
;
3592 static test_return_t
pre_md5(memcached_st
*memc
)
3594 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3596 return TEST_SUCCESS
;
3599 static test_return_t
pre_crc(memcached_st
*memc
)
3601 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3603 return TEST_SUCCESS
;
3606 static test_return_t
pre_hsieh(memcached_st
*memc
)
3608 #ifdef HAVE_HSIEH_HASH
3609 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3610 return TEST_SUCCESS
;
3613 return TEST_SKIPPED
;
3617 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3619 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3621 return TEST_SUCCESS
;
3624 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3626 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3628 return TEST_SUCCESS
;
3631 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3633 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3635 return TEST_SUCCESS
;
3638 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3640 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3642 return TEST_SUCCESS
;
3645 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3647 memcached_return_t rc
;
3650 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3651 test_true(rc
== MEMCACHED_SUCCESS
);
3653 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3654 test_true(value
== 1);
3656 return TEST_SUCCESS
;
3659 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3661 memcached_return_t rc
;
3664 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3665 test_true(rc
== MEMCACHED_SUCCESS
);
3667 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3668 test_true(value
== 1);
3670 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3671 test_true(rc
== MEMCACHED_SUCCESS
);
3673 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3674 test_true(value
== MEMCACHED_HASH_MD5
);
3676 return TEST_SUCCESS
;
3680 @note This should be testing to see if the server really supports the binary protocol.
3682 static test_return_t
pre_binary(memcached_st
*memc
)
3684 memcached_return_t rc
= MEMCACHED_FAILURE
;
3686 if (libmemcached_util_version_check(memc
, 1, 4, 4))
3688 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3689 test_true(rc
== MEMCACHED_SUCCESS
);
3690 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3693 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3696 static test_return_t
pre_sasl(memcached_st
*memc
)
3698 memcached_return_t rc
= MEMCACHED_FAILURE
;
3700 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
3701 const char *server
= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
3702 const char *user
= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
3703 const char *pass
= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
3705 if (server
!= NULL
&& user
!= NULL
&& pass
!= NULL
)
3707 memcached_server_st
*servers
= memcached_servers_parse(server
);
3708 test_true(servers
!= NULL
);
3709 memcached_servers_reset(memc
);
3710 test_true(memcached_server_push(memc
, servers
) == MEMCACHED_SUCCESS
);
3711 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3712 rc
= memcached_set_sasl_auth_data(memc
, user
, pass
);
3713 test_true(rc
== MEMCACHED_SUCCESS
);
3719 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3722 static test_return_t
pre_replication(memcached_st
*memc
)
3724 test_return_t test_rc
;
3725 test_rc
= pre_binary(memc
);
3727 if (test_rc
!= TEST_SUCCESS
)
3731 * Make sure that we store the item on all servers
3732 * (master + replicas == number of servers)
3734 memcached_return_t rc
;
3735 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3736 memcached_server_count(memc
) - 1);
3737 test_true(rc
== MEMCACHED_SUCCESS
);
3738 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memcached_server_count(memc
) - 1);
3740 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3744 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3748 rc
= pre_replication(memc
);
3749 if (rc
!= TEST_SUCCESS
)
3752 rc
= pre_nonblock(memc
);
3758 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3762 #ifdef HARD_MALLOC_TESTS
3763 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3771 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3775 #ifdef HARD_MALLOC_TESTS
3776 void *ret
= malloc(size
+ 8);
3779 ret
= (void*)((caddr_t
)ret
+ 8);
3782 void *ret
= malloc(size
);
3787 memset(ret
, 0xff, size
);
3794 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *context
)
3797 #ifdef HARD_MALLOC_TESTS
3798 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3799 void *nmem
= realloc(real_ptr
, size
+ 8);
3804 ret
= (void*)((caddr_t
)nmem
+ 8);
3810 return realloc(mem
, size
);
3815 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *context
)
3818 #ifdef HARD_MALLOC_TESTS
3819 void *mem
= my_malloc(ptr
, nelem
* size
);
3822 memset(mem
, 0, nelem
* size
);
3828 return calloc(nelem
, size
);
3833 static test_return_t
set_prefix(memcached_st
*memc
)
3835 memcached_return_t rc
;
3836 const char *key
= "mine";
3839 /* Make sure be default none exists */
3840 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3841 test_true(rc
== MEMCACHED_FAILURE
);
3843 /* Test a clean set */
3844 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3845 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_last_error_message(memc
));
3847 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3849 test_true(memcmp(value
, key
, 4) == 0);
3850 test_true(rc
== MEMCACHED_SUCCESS
);
3852 /* Test that we can turn it off */
3853 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3854 test_true(rc
== MEMCACHED_SUCCESS
);
3856 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3858 test_true(rc
== MEMCACHED_FAILURE
);
3860 /* Now setup for main test */
3861 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3862 test_true(rc
== MEMCACHED_SUCCESS
);
3864 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3866 test_true(rc
== MEMCACHED_SUCCESS
);
3867 test_true(memcmp(value
, key
, 4) == 0);
3869 /* Set to Zero, and then Set to something too large */
3872 memset(long_key
, 0, 255);
3874 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3875 test_true(rc
== MEMCACHED_SUCCESS
);
3877 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3879 test_true(rc
== MEMCACHED_FAILURE
);
3880 test_true(value
== NULL
);
3882 /* Test a long key for failure */
3883 /* TODO, extend test to determine based on setting, what result should be */
3884 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3885 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3886 //test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3887 test_true(rc
== MEMCACHED_SUCCESS
);
3889 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3890 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3891 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3892 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3894 /* Test for a bad prefix, but with a short key */
3895 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3896 test_true(rc
== MEMCACHED_SUCCESS
);
3898 strncpy(long_key
, "dog cat", sizeof(long_key
));
3899 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3900 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3903 return TEST_SUCCESS
;
3907 #ifdef MEMCACHED_ENABLE_DEPRECATED
3908 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3910 void *test_ptr
= NULL
;
3913 memcached_malloc_fn malloc_cb
=
3914 (memcached_malloc_fn
)my_malloc
;
3915 cb_ptr
= *(void **)&malloc_cb
;
3916 memcached_return_t rc
;
3918 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
3919 test_true(rc
== MEMCACHED_SUCCESS
);
3920 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3921 test_true(rc
== MEMCACHED_SUCCESS
);
3922 test_true(test_ptr
== cb_ptr
);
3926 memcached_realloc_fn realloc_cb
=
3927 (memcached_realloc_fn
)my_realloc
;
3928 cb_ptr
= *(void **)&realloc_cb
;
3929 memcached_return_t rc
;
3931 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
3932 test_true(rc
== MEMCACHED_SUCCESS
);
3933 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3934 test_true(rc
== MEMCACHED_SUCCESS
);
3935 test_true(test_ptr
== cb_ptr
);
3939 memcached_free_fn free_cb
=
3940 (memcached_free_fn
)my_free
;
3941 cb_ptr
= *(void **)&free_cb
;
3942 memcached_return_t rc
;
3944 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
3945 test_true(rc
== MEMCACHED_SUCCESS
);
3946 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3947 test_true(rc
== MEMCACHED_SUCCESS
);
3948 test_true(test_ptr
== cb_ptr
);
3951 return TEST_SUCCESS
;
3956 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3958 memcached_return_t rc
;
3959 rc
= memcached_set_memory_allocators(memc
, NULL
, my_free
,
3960 my_realloc
, my_calloc
, NULL
);
3961 test_true(rc
== MEMCACHED_FAILURE
);
3963 rc
= memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3964 my_realloc
, my_calloc
, NULL
);
3966 memcached_malloc_fn mem_malloc
;
3967 memcached_free_fn mem_free
;
3968 memcached_realloc_fn mem_realloc
;
3969 memcached_calloc_fn mem_calloc
;
3970 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3971 &mem_realloc
, &mem_calloc
);
3973 test_true(mem_malloc
== my_malloc
);
3974 test_true(mem_realloc
== my_realloc
);
3975 test_true(mem_calloc
== my_calloc
);
3976 test_true(mem_free
== my_free
);
3978 return TEST_SUCCESS
;
3981 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3984 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3985 memcached_hash_t hash
;
3986 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3987 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3990 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3991 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3993 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3995 if (hash
!= MEMCACHED_HASH_CRC
)
3996 return TEST_SKIPPED
;
3998 return TEST_SUCCESS
;
4001 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
4004 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4005 memcached_hash_t hash
;
4006 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4007 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
4010 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4011 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4013 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4015 if (hash
!= MEMCACHED_HASH_HSIEH
)
4016 return TEST_SKIPPED
;
4019 return TEST_SUCCESS
;
4022 static test_return_t
enable_cas(memcached_st
*memc
)
4024 unsigned int set
= 1;
4026 if (libmemcached_util_version_check(memc
, 1, 2, 4))
4028 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
4030 return TEST_SUCCESS
;
4033 return TEST_SKIPPED
;
4036 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
4038 memcached_version(memc
);
4040 memcached_server_instance_st instance
=
4041 memcached_server_instance_by_position(memc
, 0);
4043 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
4044 || instance
->minor_version
> 2)
4046 return TEST_SUCCESS
;
4049 return TEST_SKIPPED
;
4052 static test_return_t
pre_unix_socket(memcached_st
*memc
)
4054 memcached_return_t rc
;
4057 memcached_servers_reset(memc
);
4059 if (stat("/tmp/memcached.socket", &buf
))
4060 return TEST_SKIPPED
;
4062 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
4064 return ( rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_FAILURE
);
4067 static test_return_t
pre_nodelay(memcached_st
*memc
)
4069 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
4070 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
4072 return TEST_SUCCESS
;
4075 static test_return_t
pre_settimer(memcached_st
*memc
)
4077 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4078 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4080 return TEST_SUCCESS
;
4083 static test_return_t
poll_timeout(memcached_st
*memc
)
4089 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4091 timeout
= (size_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
4093 test_true(timeout
== 100);
4095 return TEST_SUCCESS
;
4098 static test_return_t
noreply_test(memcached_st
*memc
)
4100 memcached_return_t ret
;
4101 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
4102 test_true(ret
== MEMCACHED_SUCCESS
);
4103 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4104 test_true(ret
== MEMCACHED_SUCCESS
);
4105 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
4106 test_true(ret
== MEMCACHED_SUCCESS
);
4107 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
4108 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
4109 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
4111 for (int count
=0; count
< 5; ++count
)
4113 for (size_t x
= 0; x
< 100; ++x
)
4116 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4117 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4119 size_t len
= (size_t)check_length
;
4124 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4127 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4130 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4133 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4136 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4142 test_true(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
4146 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4147 ** API and is _ONLY_ done this way to verify that the library works the
4148 ** way it is supposed to do!!!!
4151 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4153 memcached_server_instance_st instance
=
4154 memcached_server_instance_by_position(memc
, x
);
4155 no_msg
+=(int)(instance
->cursor_active
);
4158 test_true(no_msg
== 0);
4159 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4162 ** Now validate that all items was set properly!
4164 for (size_t x
= 0; x
< 100; ++x
)
4168 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4170 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4172 size_t len
= (size_t)check_length
;
4175 char* value
=memcached_get(memc
, key
, strlen(key
),
4176 &length
, &flags
, &ret
);
4177 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4180 case 0: /* FALLTHROUGH */
4181 case 1: /* FALLTHROUGH */
4183 test_true(strncmp(value
, key
, len
) == 0);
4184 test_true(len
== length
);
4187 test_true(length
== len
* 2);
4190 test_true(length
== len
* 3);
4200 /* Try setting an illegal cas value (should not return an error to
4201 * the caller (because we don't expect a return message from the server)
4203 const char* keys
[]= {"0"};
4204 size_t lengths
[]= {1};
4207 memcached_result_st results_obj
;
4208 memcached_result_st
*results
;
4209 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4210 test_true(ret
== MEMCACHED_SUCCESS
);
4212 results
= memcached_result_create(memc
, &results_obj
);
4214 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4216 test_true(ret
== MEMCACHED_SUCCESS
);
4217 uint64_t cas
= memcached_result_cas(results
);
4218 memcached_result_free(&results_obj
);
4220 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4221 test_true(ret
== MEMCACHED_SUCCESS
);
4224 * The item will have a new cas value, so try to set it again with the old
4225 * value. This should fail!
4227 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4228 test_true(ret
== MEMCACHED_SUCCESS
);
4229 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4230 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4231 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4234 return TEST_SUCCESS
;
4237 static test_return_t
analyzer_test(memcached_st
*memc
)
4239 memcached_return_t rc
;
4240 memcached_stat_st
*memc_stat
;
4241 memcached_analysis_st
*report
;
4243 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4244 test_true(rc
== MEMCACHED_SUCCESS
);
4245 test_true(memc_stat
);
4247 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4248 test_true(rc
== MEMCACHED_SUCCESS
);
4252 memcached_stat_free(NULL
, memc_stat
);
4254 return TEST_SUCCESS
;
4257 /* Count the objects */
4258 static memcached_return_t
callback_dump_counter(const memcached_st
*ptr
,
4263 (void)ptr
; (void)key
; (void)key_length
;
4264 size_t *counter
= (size_t *)context
;
4266 *counter
= *counter
+ 1;
4268 return MEMCACHED_SUCCESS
;
4271 static test_return_t
dump_test(memcached_st
*memc
)
4273 memcached_return_t rc
;
4275 memcached_dump_fn callbacks
[1];
4276 test_return_t main_rc
;
4278 callbacks
[0]= &callback_dump_counter
;
4280 /* No support for Binary protocol yet */
4281 if (memc
->flags
.binary_protocol
)
4282 return TEST_SUCCESS
;
4284 main_rc
= set_test3(memc
);
4286 test_true (main_rc
== TEST_SUCCESS
);
4288 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
4289 test_true(rc
== MEMCACHED_SUCCESS
);
4291 /* We may have more then 32 if our previous flush has not completed */
4292 test_true(counter
>= 32);
4294 return TEST_SUCCESS
;
4297 #ifdef HAVE_LIBMEMCACHEDUTIL
4298 static void* connection_release(void *arg
)
4301 memcached_pool_st
* pool
;
4306 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
4310 #define POOL_SIZE 10
4311 static test_return_t
connection_pool_test(memcached_st
*memc
)
4313 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4314 test_true(pool
!= NULL
);
4315 memcached_st
*mmc
[POOL_SIZE
];
4316 memcached_return_t rc
;
4318 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4320 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4321 test_true(mmc
[x
] != NULL
);
4322 test_true(rc
== MEMCACHED_SUCCESS
);
4325 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4326 test_true(rc
== MEMCACHED_SUCCESS
);
4330 memcached_pool_st
* pool
;
4332 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
4333 pthread_create(&tid
, NULL
, connection_release
, &item
);
4334 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4335 test_true(rc
== MEMCACHED_SUCCESS
);
4336 pthread_join(tid
, NULL
);
4337 test_true(mmc
[9] == item
.mmc
);
4338 const char *key
= "key";
4339 size_t keylen
= strlen(key
);
4341 // verify that I can do ops with all connections
4342 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
4343 test_true(rc
== MEMCACHED_SUCCESS
);
4345 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4347 uint64_t number_value
;
4348 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
4349 test_true(rc
== MEMCACHED_SUCCESS
);
4350 test_true(number_value
== (x
+1));
4354 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4356 test_true(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
4360 /* verify that I can set behaviors on the pool when I don't have all
4361 * of the connections in the pool. It should however be enabled
4362 * when I push the item into the pool
4364 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4365 test_true(mmc
[0] != NULL
);
4367 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4368 test_true(rc
== MEMCACHED_SUCCESS
);
4370 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4371 test_true(mmc
[1] != NULL
);
4373 test_true(memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4374 test_true(memcached_pool_push(pool
, mmc
[1]) == MEMCACHED_SUCCESS
);
4375 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4377 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4378 test_true(memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4379 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4381 test_true(memcached_pool_destroy(pool
) == memc
);
4383 return TEST_SUCCESS
;
4386 static test_return_t
util_version_test(memcached_st
*memc
)
4390 if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4391 test_true(if_successful
== true);
4393 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4395 // We expect failure
4398 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4399 fprintf(stderr
, "\nDumping Server Information\n\n");
4400 memcached_server_fn callbacks
[1];
4402 callbacks
[0]= dump_server_information
;
4403 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4404 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4406 test_true(if_successful
== false);
4408 memcached_server_instance_st instance
=
4409 memcached_server_instance_by_position(memc
, 0);
4411 memcached_version(memc
);
4413 // We only use one binary when we test, so this should be just fine.
4414 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4415 test_true(if_successful
== true);
4417 if (instance
->micro_version
> 0)
4418 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4419 else if (instance
->minor_version
> 0)
4420 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4421 else if (instance
->major_version
> 0)
4422 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4424 test_true(if_successful
== true);
4426 if (instance
->micro_version
> 0)
4427 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4428 else if (instance
->minor_version
> 0)
4429 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4430 else if (instance
->major_version
> 0)
4431 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4433 test_true(if_successful
== false);
4435 return TEST_SUCCESS
;
4438 static test_return_t
ping_test(memcached_st
*memc
)
4440 memcached_return_t rc
;
4441 memcached_server_instance_st instance
=
4442 memcached_server_instance_by_position(memc
, 0);
4444 // Test both the version that returns a code, and the one that does not.
4445 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4446 memcached_server_port(instance
), NULL
));
4448 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4449 memcached_server_port(instance
), &rc
));
4451 test_true(rc
== MEMCACHED_SUCCESS
);
4453 return TEST_SUCCESS
;
4459 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4463 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4464 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4465 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4466 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4467 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4468 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4469 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4470 #ifdef HAVE_HSIEH_HASH
4471 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4473 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4474 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4475 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4477 return TEST_SUCCESS
;
4481 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4483 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4484 #ifdef HAVE_HSIEH_HASH
4485 expected_rc
= MEMCACHED_SUCCESS
;
4487 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4488 (uint64_t)MEMCACHED_HASH_HSIEH
);
4489 test_true(rc
== expected_rc
);
4491 return TEST_SUCCESS
;
4494 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4496 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4497 #ifdef HAVE_MURMUR_HASH
4498 expected_rc
= MEMCACHED_SUCCESS
;
4500 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4501 (uint64_t)MEMCACHED_HASH_MURMUR
);
4502 test_true(rc
== expected_rc
);
4504 return TEST_SUCCESS
;
4507 static test_return_t
one_at_a_time_run (memcached_st
*memc
)
4513 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4517 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
);
4518 test_true(one_at_a_time_values
[x
] == hash_val
);
4521 return TEST_SUCCESS
;
4524 static test_return_t
md5_run (memcached_st
*memc
)
4530 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4534 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4535 test_true(md5_values
[x
] == hash_val
);
4538 return TEST_SUCCESS
;
4541 static test_return_t
crc_run (memcached_st
*memc
)
4547 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4551 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4552 test_true(crc_values
[x
] == hash_val
);
4555 return TEST_SUCCESS
;
4558 static test_return_t
fnv1_64_run (memcached_st
*memc
)
4564 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4568 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4569 test_true(fnv1_64_values
[x
] == hash_val
);
4572 return TEST_SUCCESS
;
4575 static test_return_t
fnv1a_64_run (memcached_st
*memc
)
4581 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4585 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4586 test_true(fnv1a_64_values
[x
] == hash_val
);
4589 return TEST_SUCCESS
;
4592 static test_return_t
fnv1_32_run (memcached_st
*memc
)
4598 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4602 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4603 test_true(fnv1_32_values
[x
] == hash_val
);
4606 return TEST_SUCCESS
;
4609 static test_return_t
fnv1a_32_run (memcached_st
*memc
)
4615 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4619 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4620 test_true(fnv1a_32_values
[x
] == hash_val
);
4623 return TEST_SUCCESS
;
4626 static test_return_t
hsieh_run (memcached_st
*memc
)
4632 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4636 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4637 test_true(hsieh_values
[x
] == hash_val
);
4640 return TEST_SUCCESS
;
4643 static test_return_t
murmur_run (memcached_st
*memc
)
4645 #ifdef WORDS_BIGENDIAN
4646 (void)murmur_values
;
4647 return TEST_SKIPPED
;
4653 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4657 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
4658 test_true(murmur_values
[x
] == hash_val
);
4661 return TEST_SUCCESS
;
4665 static test_return_t
jenkins_run (memcached_st
*memc
)
4671 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4675 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4676 test_true(jenkins_values
[x
] == hash_val
);
4679 return TEST_SUCCESS
;
4682 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *context
)
4685 return libhashkit_md5(string
, string_length
);
4688 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *context
)
4691 return libhashkit_crc32(string
, string_length
);
4694 static test_return_t
memcached_get_hashkit_test (memcached_st
*memc
)
4698 const hashkit_st
*kit
;
4700 hashkit_return_t hash_rc
;
4702 uint32_t md5_hosts
[]= {4U, 1U, 0U, 1U, 4U, 2U, 0U, 3U, 0U, 0U, 3U, 1U, 0U, 0U, 1U, 3U, 0U, 0U, 0U, 3U, 1U, 0U, 4U, 4U, 3U};
4703 uint32_t crc_hosts
[]= {2U, 4U, 1U, 0U, 2U, 4U, 4U, 4U, 1U, 2U, 3U, 4U, 3U, 4U, 1U, 3U, 3U, 2U, 0U, 0U, 0U, 1U, 2U, 4U, 0U};
4705 kit
= memcached_get_hashkit(memc
);
4707 hashkit_clone(&new_kit
, kit
);
4708 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
);
4709 test_true(hash_rc
== HASHKIT_SUCCESS
);
4711 memcached_set_hashkit(memc
, &new_kit
);
4714 Verify Setting the hash.
4716 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4720 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4721 test_true(md5_values
[x
] == hash_val
);
4726 Now check memcached_st.
4728 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4732 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4733 test_true(md5_hosts
[x
] == hash_val
);
4736 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
);
4737 test_true(hash_rc
== HASHKIT_SUCCESS
);
4739 memcached_set_hashkit(memc
, &new_kit
);
4742 Verify Setting the hash.
4744 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4748 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4749 test_true(crc_values
[x
] == hash_val
);
4752 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4756 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4757 test_true(crc_hosts
[x
] == hash_val
);
4760 return TEST_SUCCESS
;
4764 Test case adapted from John Gorman <johngorman2@gmail.com>
4766 We are testing the error condition when we connect to a server via memcached_get()
4767 but find that the server is not available.
4769 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*memc
)
4772 memcached_st
*tl_memc_h
;
4773 memcached_server_st
*servers
;
4775 const char *key
= "MemcachedLives";
4778 memcached_return rc
;
4782 tl_memc_h
= memcached_create(NULL
);
4783 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4784 memcached_server_push(tl_memc_h
, servers
);
4785 memcached_server_list_free(servers
);
4787 // See if memcached is reachable.
4788 value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4791 test_true(len
== 0);
4792 test_false(rc
== MEMCACHED_SUCCESS
);
4794 memcached_free(tl_memc_h
);
4796 return TEST_SUCCESS
;
4800 We connect to a server which exists, but search for a key that does not exist.
4802 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4804 const char *key
= "MemcachedKeyNotEXIST";
4807 memcached_return rc
;
4810 // See if memcached is reachable.
4811 value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4814 test_true(len
== 0);
4815 test_true(rc
== MEMCACHED_NOTFOUND
);
4817 return TEST_SUCCESS
;
4821 Test case adapted from John Gorman <johngorman2@gmail.com>
4823 We are testing the error condition when we connect to a server via memcached_get_by_key()
4824 but find that the server is not available.
4826 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4829 memcached_st
*tl_memc_h
;
4830 memcached_server_st
*servers
;
4832 const char *key
= "MemcachedLives";
4835 memcached_return rc
;
4839 tl_memc_h
= memcached_create(NULL
);
4840 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4841 memcached_server_push(tl_memc_h
, servers
);
4842 memcached_server_list_free(servers
);
4844 // See if memcached is reachable.
4845 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4848 test_true(len
== 0);
4849 test_false(rc
== MEMCACHED_SUCCESS
);
4851 memcached_free(tl_memc_h
);
4853 return TEST_SUCCESS
;
4857 We connect to a server which exists, but search for a key that does not exist.
4859 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4861 const char *key
= "MemcachedKeyNotEXIST";
4864 memcached_return rc
;
4867 // See if memcached is reachable.
4868 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4871 test_true(len
== 0);
4872 test_true(rc
== MEMCACHED_NOTFOUND
);
4874 return TEST_SUCCESS
;
4878 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*trash
)
4880 memcached_return_t rc
;
4883 memcached_server_st
*server_pool
;
4888 memc
= memcached_create(NULL
);
4891 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
4892 test_true(rc
== MEMCACHED_SUCCESS
);
4894 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
4895 test_true(value
== 1);
4897 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
) == MEMCACHED_SUCCESS
);
4898 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
);
4901 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");
4902 memcached_server_push(memc
, server_pool
);
4904 /* verify that the server list was parsed okay. */
4905 test_true(memcached_server_count(memc
) == 8);
4906 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
4907 test_true(server_pool
[0].port
== 11211);
4908 test_true(server_pool
[0].weight
== 600);
4909 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
4910 test_true(server_pool
[2].port
== 11211);
4911 test_true(server_pool
[2].weight
== 200);
4912 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
4913 test_true(server_pool
[7].port
== 11211);
4914 test_true(server_pool
[7].weight
== 100);
4916 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
4917 * us test the boundary wraparound.
4919 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
4921 /* verify the standard ketama set. */
4922 for (x
= 0; x
< 99; x
++)
4924 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
4925 memcached_server_instance_st instance
=
4926 memcached_server_instance_by_position(memc
, server_idx
);
4927 const char *hostname
= memcached_server_name(instance
);
4929 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
4932 memcached_server_list_free(server_pool
);
4933 memcached_free(memc
);
4935 return TEST_SUCCESS
;
4938 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*trash
)
4940 memcached_return_t rc
;
4942 memcached_server_st
*server_pool
;
4947 memc
= memcached_create(NULL
);
4950 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
4951 test_true(rc
== MEMCACHED_SUCCESS
);
4953 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
4954 test_true(value
== 1);
4956 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
4957 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
);
4959 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");
4960 assert(server_pool
);
4961 memcached_server_push(memc
, server_pool
);
4963 /* verify that the server list was parsed okay. */
4964 test_true(memcached_server_count(memc
) == 8);
4965 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
4966 test_true(server_pool
[0].port
== 11211);
4967 test_true(server_pool
[0].weight
== 600);
4968 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
4969 test_true(server_pool
[2].port
== 11211);
4970 test_true(server_pool
[2].weight
== 200);
4971 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
4972 test_true(server_pool
[7].port
== 11211);
4973 test_true(server_pool
[7].weight
== 100);
4975 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
4976 * us test the boundary wraparound.
4978 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
4980 /* verify the standard ketama set. */
4981 for (uint32_t x
= 0; x
< 99; x
++)
4983 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
4985 memcached_server_instance_st instance
=
4986 memcached_server_instance_by_position(memc
, server_idx
);
4988 const char *hostname
= memcached_server_name(instance
);
4990 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
4993 memcached_server_list_free(server_pool
);
4994 memcached_free(memc
);
4996 return TEST_SUCCESS
;
4999 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5001 test_return_t test_rc
;
5002 test_rc
= pre_binary(memc
);
5004 if (test_rc
!= TEST_SUCCESS
)
5007 memcached_return_t ret
;
5008 const char *key
= "regression_bug_434484";
5009 size_t keylen
= strlen(key
);
5011 ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5012 test_true(ret
== MEMCACHED_NOTSTORED
);
5014 size_t size
= 2048 * 1024;
5015 void *data
= calloc(1, size
);
5016 test_true(data
!= NULL
);
5017 ret
= memcached_set(memc
, key
, keylen
, data
, size
, 0, 0);
5018 test_true(ret
== MEMCACHED_E2BIG
);
5021 return TEST_SUCCESS
;
5024 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5026 test_return_t test_rc
;
5027 test_rc
= pre_binary(memc
);
5029 if (test_rc
!= TEST_SUCCESS
)
5032 memcached_return_t rc
;
5034 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5037 * I only want to hit only _one_ server so I know the number of requests I'm
5038 * sending in the pipleine to the server. Let's try to do a multiget of
5039 * 1024 (that should satisfy most users don't you think?). Future versions
5040 * will include a mget_execute function call if you need a higher number.
5042 uint32_t number_of_hosts
= memcached_server_count(memc
);
5043 memc
->number_of_hosts
= 1;
5044 const size_t max_keys
= 1024;
5045 char **keys
= calloc(max_keys
, sizeof(char*));
5046 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5048 for (size_t x
= 0; x
< max_keys
; ++x
)
5052 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5054 test_true(keys
[x
] != NULL
);
5058 * Run two times.. the first time we should have 100% cache miss,
5059 * and the second time we should have 100% cache hits
5061 for (size_t y
= 0; y
< 2; y
++)
5063 rc
= memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
);
5064 test_true(rc
== MEMCACHED_SUCCESS
);
5065 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5069 /* The first iteration should give me a 100% cache miss. verify that*/
5070 char blob
[1024]= { 0 };
5072 test_true(counter
== 0);
5074 for (size_t x
= 0; x
< max_keys
; ++x
)
5076 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5077 blob
, sizeof(blob
), 0, 0);
5078 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5083 /* Verify that we received all of the key/value pairs */
5084 test_true(counter
== max_keys
);
5088 /* Release allocated resources */
5089 for (size_t x
= 0; x
< max_keys
; ++x
)
5096 memc
->number_of_hosts
= number_of_hosts
;
5098 return TEST_SUCCESS
;
5101 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5103 memcached_return_t rc
;
5104 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5105 test_true(rc
== MEMCACHED_SUCCESS
);
5107 return regression_bug_434843(memc
);
5110 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5112 memcached_return_t rc
;
5113 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5114 test_true(rc
== MEMCACHED_SUCCESS
);
5116 char *bytes
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5117 test_true(rc
== MEMCACHED_SUCCESS
);
5118 test_true(bytes
!= NULL
);
5119 char *bytes_read
= memcached_stat_get_value(memc
, memc_stat
,
5121 test_true(rc
== MEMCACHED_SUCCESS
);
5122 test_true(bytes_read
!= NULL
);
5124 char *bytes_written
= memcached_stat_get_value(memc
, memc_stat
,
5125 "bytes_written", &rc
);
5126 test_true(rc
== MEMCACHED_SUCCESS
);
5127 test_true(bytes_written
!= NULL
);
5129 test_true(strcmp(bytes
, bytes_read
) != 0);
5130 test_true(strcmp(bytes
, bytes_written
) != 0);
5132 /* Release allocated resources */
5135 free(bytes_written
);
5136 memcached_stat_free(NULL
, memc_stat
);
5138 return TEST_SUCCESS
;
5142 * The test case isn't obvious so I should probably document why
5143 * it works the way it does. Bug 442914 was caused by a bug
5144 * in the logic in memcached_purge (it did not handle the case
5145 * where the number of bytes sent was equal to the watermark).
5146 * In this test case, create messages so that we hit that case
5147 * and then disable noreply mode and issue a new command to
5148 * verify that it isn't stuck. If we change the format for the
5149 * delete command or the watermarks, we need to update this
5152 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5154 memcached_return_t rc
;
5155 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
5156 test_true(rc
== MEMCACHED_SUCCESS
);
5157 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5159 uint32_t number_of_hosts
= memcached_server_count(memc
);
5160 memc
->number_of_hosts
= 1;
5165 for (uint32_t x
= 0; x
< 250; ++x
)
5167 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5168 rc
= memcached_delete(memc
, k
, len
, 0);
5169 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5172 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5175 rc
= memcached_delete(memc
, k
, len
, 0);
5176 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5178 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0);
5179 test_true(rc
== MEMCACHED_SUCCESS
);
5180 rc
= memcached_delete(memc
, k
, len
, 0);
5181 test_true(rc
== MEMCACHED_NOTFOUND
);
5183 memc
->number_of_hosts
= number_of_hosts
;
5185 return TEST_SUCCESS
;
5188 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5190 memcached_server_instance_st instance_one
;
5191 memcached_server_instance_st instance_two
;
5193 if (memcached_server_count(memc
) < 3 || pre_replication(memc
) != TEST_SUCCESS
)
5194 return TEST_SKIPPED
;
5196 memcached_return_t rc
;
5198 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2);
5199 test_true(rc
== MEMCACHED_SUCCESS
);
5201 const size_t max_keys
= 100;
5202 char **keys
= calloc(max_keys
, sizeof(char*));
5203 size_t *key_length
= calloc(max_keys
, sizeof(size_t));
5205 for (size_t x
= 0; x
< max_keys
; ++x
)
5209 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5211 test_true(keys
[x
] != NULL
);
5212 rc
= memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0);
5213 test_true(rc
== MEMCACHED_SUCCESS
);
5217 ** We are using the quiet commands to store the replicas, so we need
5218 ** to ensure that all of them are processed before we can continue.
5219 ** In the test we go directly from storing the object to trying to
5220 ** receive the object from all of the different servers, so we
5221 ** could end up in a race condition (the memcached server hasn't yet
5222 ** processed the quiet command from the replication set when it process
5223 ** the request from the other client (created by the clone)). As a
5224 ** workaround for that we call memcached_quit to send the quit command
5225 ** to the server and wait for the response ;-) If you use the test code
5226 ** as an example for your own code, please note that you shouldn't need
5229 memcached_quit(memc
);
5231 /* Verify that all messages are stored, and we didn't stuff too much
5234 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5235 test_true(rc
== MEMCACHED_SUCCESS
);
5238 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5239 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5240 /* Verify that we received all of the key/value pairs */
5241 test_true(counter
== max_keys
);
5243 memcached_quit(memc
);
5245 * Don't do the following in your code. I am abusing the internal details
5246 * within the library, and this is not a supported interface.
5247 * This is to verify correct behavior in the library. Fake that two servers
5250 instance_one
= memcached_server_instance_by_position(memc
, 0);
5251 instance_two
= memcached_server_instance_by_position(memc
, 2);
5252 in_port_t port0
= instance_one
->port
;
5253 in_port_t port2
= instance_two
->port
;
5255 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5256 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5258 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5259 test_true(rc
== MEMCACHED_SUCCESS
);
5262 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5263 test_true(counter
== (unsigned int)max_keys
);
5265 /* restore the memc handle */
5266 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5267 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5269 memcached_quit(memc
);
5271 /* Remove half of the objects */
5272 for (size_t x
= 0; x
< max_keys
; ++x
)
5276 rc
= memcached_delete(memc
, keys
[x
], key_length
[x
], 0);
5277 test_true(rc
== MEMCACHED_SUCCESS
);
5281 memcached_quit(memc
);
5282 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5283 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5285 /* now retry the command, this time we should have cache misses */
5286 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5287 test_true(rc
== MEMCACHED_SUCCESS
);
5290 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5291 test_true(counter
== (unsigned int)(max_keys
>> 1));
5293 /* Release allocated resources */
5294 for (size_t x
= 0; x
< max_keys
; ++x
)
5301 /* restore the memc handle */
5302 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5303 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5305 return TEST_SUCCESS
;
5308 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5310 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5311 test_true(memc_clone
!= NULL
);
5312 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5314 memcached_server_instance_st instance
=
5315 memcached_server_instance_by_position(memc_clone
, 0);
5317 if (instance
->major_version
> 1 ||
5318 (instance
->major_version
== 1 &&
5319 instance
->minor_version
> 2))
5321 /* Binary protocol doesn't support deferred delete */
5322 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5323 test_true(bin_clone
!= NULL
);
5324 test_true(memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1) == MEMCACHED_SUCCESS
);
5325 test_true(memcached_delete(bin_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5326 memcached_free(bin_clone
);
5328 memcached_quit(memc_clone
);
5330 /* If we know the server version, deferred delete should fail
5331 * with invalid arguments */
5332 test_true(memcached_delete(memc_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5334 /* If we don't know the server version, we should get a protocol error */
5335 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5337 /* but there is a bug in some of the memcached servers (1.4) that treats
5338 * the counter as noreply so it doesn't send the proper error message
5340 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5342 /* And buffered mode should be disabled and we should get protocol error */
5343 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5344 rc
= memcached_delete(memc
, "foo", 3, 1);
5345 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5347 /* Same goes for noreply... */
5348 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1) == MEMCACHED_SUCCESS
);
5349 rc
= memcached_delete(memc
, "foo", 3, 1);
5350 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5352 /* but a normal request should go through (and be buffered) */
5353 test_true((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_BUFFERED
);
5354 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
5356 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0) == MEMCACHED_SUCCESS
);
5357 /* unbuffered noreply should be success */
5358 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_SUCCESS
);
5359 /* unbuffered with reply should be not found... */
5360 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0) == MEMCACHED_SUCCESS
);
5361 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_NOTFOUND
);
5364 memcached_free(memc_clone
);
5365 return TEST_SUCCESS
;
5369 /* Test memcached_server_get_last_disconnect
5370 * For a working server set, shall be NULL
5371 * For a set of non existing server, shall not be NULL
5373 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5375 memcached_return_t rc
;
5376 memcached_server_instance_st disconnected_server
;
5378 /* With the working set of server */
5379 const char *key
= "marmotte";
5380 const char *value
= "milka";
5382 memcached_reset_last_disconnected_server(memc
);
5383 rc
= memcached_set(memc
, key
, strlen(key
),
5384 value
, strlen(value
),
5385 (time_t)0, (uint32_t)0);
5386 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5388 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5389 test_true(disconnected_server
== NULL
);
5391 /* With a non existing server */
5393 memcached_server_st
*servers
;
5395 const char *server_list
= "localhost:9";
5397 servers
= memcached_servers_parse(server_list
);
5399 mine
= memcached_create(NULL
);
5400 rc
= memcached_server_push(mine
, servers
);
5401 test_true(rc
== MEMCACHED_SUCCESS
);
5402 memcached_server_list_free(servers
);
5405 rc
= memcached_set(mine
, key
, strlen(key
),
5406 value
, strlen(value
),
5407 (time_t)0, (uint32_t)0);
5408 test_true(rc
!= MEMCACHED_SUCCESS
);
5410 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5411 if (disconnected_server
== NULL
)
5413 fprintf(stderr
, "RC %s\n", memcached_strerror(mine
, rc
));
5416 test_true(disconnected_server
!= NULL
);
5417 test_true(memcached_server_port(disconnected_server
)== 9);
5418 test_true(strncmp(memcached_server_name(disconnected_server
),"localhost",9) == 0);
5420 memcached_quit(mine
);
5421 memcached_free(mine
);
5423 return TEST_SUCCESS
;
5426 static test_return_t
test_verbosity(memcached_st
*memc
)
5428 memcached_verbosity(memc
, 3);
5430 return TEST_SUCCESS
;
5433 static test_return_t
test_server_failure(memcached_st
*memc
)
5435 memcached_st
*local_memc
;
5436 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
5438 local_memc
= memcached_create(NULL
);
5440 memcached_server_add(local_memc
, memcached_server_name(instance
), memcached_server_port(instance
));
5441 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 2);
5443 uint32_t server_count
= memcached_server_count(local_memc
);
5445 test_true(server_count
== 1);
5447 // Disable the server
5448 instance
= memcached_server_instance_by_position(local_memc
, 0);
5449 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 2;
5451 memcached_return_t rc
;
5452 rc
= memcached_set(local_memc
, "foo", strlen("foo"),
5454 (time_t)0, (uint32_t)0);
5455 test_true(rc
== MEMCACHED_SERVER_MARKED_DEAD
);
5457 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5458 rc
= memcached_set(local_memc
, "foo", strlen("foo"),
5460 (time_t)0, (uint32_t)0);
5461 test_true(rc
== MEMCACHED_SUCCESS
);
5464 memcached_free(local_memc
);
5466 return TEST_SUCCESS
;
5469 static test_return_t
test_cull_servers(memcached_st
*memc
)
5471 uint32_t count
= memcached_server_count(memc
);
5473 // Do not do this in your code, it is not supported.
5474 memc
->servers
[1].options
.is_dead
= true;
5475 memc
->state
.is_time_for_rebuild
= true;
5477 uint32_t new_count
= memcached_server_count(memc
);
5478 test_true(count
== new_count
);
5481 test_true(count
== new_count
+ 1 );
5484 return TEST_SUCCESS
;
5488 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5489 const char *key
, size_t key_length
,
5490 const char *value
, size_t value_length
,
5500 return MEMCACHED_SUCCESS
;
5503 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5505 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5506 test_true(rc
== MEMCACHED_SUCCESS
);
5508 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5509 test_true(rc
== MEMCACHED_SUCCESS
);
5511 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5512 test_true(rc
== MEMCACHED_SUCCESS
);
5514 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5515 test_true(rc
== MEMCACHED_SUCCESS
);
5517 return TEST_SUCCESS
;
5521 * This test ensures that the failure counter isn't incremented during
5522 * normal termination of the memcached instance.
5524 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5526 memcached_return_t rc
;
5527 memcached_server_instance_st instance
;
5529 /* Set value to force connection to the server */
5530 const char *key
= "marmotte";
5531 const char *value
= "milka";
5534 * Please note that I'm abusing the internal structures in libmemcached
5535 * in a non-portable way and you shouldn't be doing this. I'm only
5536 * doing this in order to verify that the library works the way it should
5538 uint32_t number_of_hosts
= memcached_server_count(memc
);
5539 memc
->number_of_hosts
= 1;
5541 /* Ensure that we are connected to the server by setting a value */
5542 rc
= memcached_set(memc
, key
, strlen(key
),
5543 value
, strlen(value
),
5544 (time_t)0, (uint32_t)0);
5545 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5548 instance
= memcached_server_instance_by_position(memc
, 0);
5549 /* The test is to see that the memcached_quit doesn't increase the
5550 * the server failure conter, so let's ensure that it is zero
5551 * before sending quit
5553 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5555 memcached_quit(memc
);
5557 /* Verify that it memcached_quit didn't increment the failure counter
5558 * Please note that this isn't bullet proof, because an error could
5561 test_true(instance
->server_failure_counter
== 0);
5563 /* restore the instance */
5564 memc
->number_of_hosts
= number_of_hosts
;
5566 return TEST_SUCCESS
;
5570 * This tests ensures expected disconnections (for some behavior changes
5571 * for instance) do not wrongly increase failure counter
5573 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5575 memcached_return rc
;
5577 memcached_st
*memc_clone
;
5578 memc_clone
= memcached_clone(NULL
, memc
);
5579 test_true(memc_clone
);
5581 /* Set value to force connection to the server */
5582 const char *key
= "marmotte";
5583 const char *value
= "milka";
5584 char *string
= NULL
;
5585 size_t string_length
;
5588 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5589 value
, strlen(value
),
5590 (time_t)0, (uint32_t)0);
5591 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5594 /* put failure limit to 1 */
5595 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5596 assert(rc
== MEMCACHED_SUCCESS
);
5598 /* Put a retry timeout to effectively activate failure_limit effect */
5599 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1);
5600 assert(rc
== MEMCACHED_SUCCESS
);
5602 /* change behavior that triggers memcached_quit()*/
5603 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5604 assert(rc
== MEMCACHED_SUCCESS
);
5607 /* Check if we still are connected */
5608 string
= memcached_get(memc_clone
, key
, strlen(key
),
5609 &string_length
, &flags
, &rc
);
5611 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
5614 memcached_free(memc_clone
);
5616 return TEST_SUCCESS
;
5623 * Test that ensures mget_execute does not end into recursive calls that finally fails
5625 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5627 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5628 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5629 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5630 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5631 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5634 return TEST_SKIPPED
; // My MAC can't handle this test
5638 * I only want to hit _one_ server so I know the number of requests I'm
5639 * sending in the pipeline.
5641 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5642 memc
->number_of_hosts
= 1;
5643 size_t max_keys
= 20480;
5646 char **keys
= calloc(max_keys
, sizeof(char*));
5647 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5649 /* First add all of the items.. */
5651 char blob
[1024]= { 0 };
5652 memcached_return rc
;
5653 for (size_t x
= 0; x
< max_keys
; ++x
)
5656 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5658 assert(keys
[x
] != NULL
);
5659 rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5661 if (rc
== MEMCACHED_SERVER_MARKED_DEAD
)
5663 break; // We are out of business
5666 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
); // MEMCACHED_TIMEOUT <-- only observed on OSX
5668 if (rc
== MEMCACHED_TIMEOUT
&& slept
== false)
5671 sleep(1);// We will try to sleep
5674 else if (rc
== MEMCACHED_TIMEOUT
&& slept
== true)
5676 // We failed to send everything.
5681 if (rc
!= MEMCACHED_SERVER_MARKED_DEAD
)
5684 /* Try to get all of them with a large multiget */
5686 memcached_execute_function callbacks
[1]= { [0]= &callback_counter
};
5687 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5688 (size_t)max_keys
, callbacks
, &counter
, 1);
5690 assert(rc
== MEMCACHED_SUCCESS
);
5691 char* the_value
= NULL
;
5692 char the_key
[MEMCACHED_MAX_KEY
];
5693 size_t the_key_length
;
5694 size_t the_value_length
;
5698 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5700 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5706 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5709 assert(rc
== MEMCACHED_END
);
5711 /* Verify that we got all of the items */
5712 assert(counter
== max_keys
);
5715 /* Release all allocated resources */
5716 for (size_t x
= 0; x
< max_keys
; ++x
)
5723 memc
->number_of_hosts
= number_of_hosts
;
5725 return TEST_SUCCESS
;
5728 static test_return_t
regression_bug_583031(memcached_st
*unused
)
5732 memcached_st
*memc
= memcached_create(NULL
);
5734 memcached_server_add(memc
, "10.2.3.4", 11211);
5736 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5737 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5738 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5739 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5740 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5741 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5743 memcached_return_t rc
;
5747 (void)memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5749 test_true_got(rc
== MEMCACHED_TIMEOUT
|| rc
== MEMCACHED_ERRNO
|| rc
== MEMCACHED_FAILURE
, memcached_strerror(memc
, rc
));
5751 memcached_free(memc
);
5753 return TEST_SUCCESS
;
5756 // Look for memory leak
5757 static test_return_t
regression_bug_728286(memcached_st
*unused
)
5760 memcached_server_st
*servers
= memcached_servers_parse("1.2.3.4:99");
5762 memcached_server_free(servers
);
5764 return TEST_SUCCESS
;
5767 static test_return_t
regression_bug_581030(memcached_st
*unused
)
5772 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5773 test_false(local_stat
);
5775 memcached_stat_free(NULL
, NULL
);
5778 return TEST_SUCCESS
;
5781 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5783 fprintf(stderr
, "Iteration #%u: ", it
);
5785 if(error
== MEMCACHED_ERRNO
)
5787 fprintf(stderr
, "system error %d from %s: %s\n",
5788 errno
, what
, strerror(errno
));
5792 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5793 memcached_strerror(mc
, error
));
5797 #define TEST_CONSTANT_CREATION 200
5799 static test_return_t
regression_bug_(memcached_st
*memc
)
5801 const char *remote_server
;
5804 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5806 return TEST_SKIPPED
;
5809 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5811 memcached_st
* mc
= memcached_create(NULL
);
5812 memcached_return rc
;
5814 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5815 if (rc
!= MEMCACHED_SUCCESS
)
5817 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5820 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5821 if (rc
!= MEMCACHED_SUCCESS
)
5823 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5826 rc
= memcached_server_add(mc
, remote_server
, 0);
5827 if (rc
!= MEMCACHED_SUCCESS
)
5829 memcached_die(mc
, rc
, "memcached_server_add", x
);
5832 const char *set_key
= "akey";
5833 const size_t set_key_len
= strlen(set_key
);
5834 const char *set_value
= "a value";
5835 const size_t set_value_len
= strlen(set_value
);
5837 if (rc
== MEMCACHED_SUCCESS
)
5841 size_t get_value_len
;
5843 uint32_t get_value_flags
;
5845 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5846 &get_value_flags
, &rc
);
5847 if (rc
!= MEMCACHED_SUCCESS
)
5849 memcached_die(mc
, rc
, "memcached_get", x
);
5855 (get_value_len
!= set_value_len
5856 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5858 fprintf(stderr
, "Values don't match?\n");
5859 rc
= MEMCACHED_FAILURE
;
5865 rc
= memcached_set(mc
,
5866 set_key
, set_key_len
,
5867 set_value
, set_value_len
,
5871 if (rc
!= MEMCACHED_SUCCESS
)
5873 memcached_die(mc
, rc
, "memcached_set", x
);
5880 if (rc
!= MEMCACHED_SUCCESS
)
5886 return TEST_SUCCESS
;
5890 * Test that the sasl authentication works. We cannot use the default
5891 * pool of servers, because that would require that all servers we want
5892 * to test supports SASL authentication, and that they use the default
5895 static test_return_t
sasl_auth_test(memcached_st
*memc
)
5897 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
5898 memcached_return_t rc
;
5900 rc
= memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
5901 test_true(rc
== MEMCACHED_SUCCESS
);
5902 test_true((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_SUCCESS
);
5903 test_true((rc
= memcached_destroy_sasl_auth_data(memc
)) == MEMCACHED_SUCCESS
);
5904 test_true((rc
= memcached_destroy_sasl_auth_data(memc
)) == MEMCACHED_FAILURE
);
5905 test_true((rc
= memcached_destroy_sasl_auth_data(NULL
)) == MEMCACHED_FAILURE
);
5906 memcached_quit(memc
);
5908 rc
= memcached_set_sasl_auth_data(memc
,
5909 getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
5910 getenv("LIBMEMCACHED_TEST_SASL_SERVER"));
5911 test_true(rc
== MEMCACHED_SUCCESS
);
5913 rc
= memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
5914 test_true(rc
== MEMCACHED_AUTH_FAILURE
);
5915 test_true(memcached_destroy_sasl_auth_data(memc
) == MEMCACHED_SUCCESS
);
5917 memcached_quit(memc
);
5918 return TEST_SUCCESS
;
5921 return TEST_FAILURE
;
5925 /* Clean the server before beginning testing */
5927 {"util_version", 1, (test_callback_fn
)util_version_test
},
5928 {"flush", 0, (test_callback_fn
)flush_test
},
5929 {"init", 0, (test_callback_fn
)init_test
},
5930 {"allocation", 0, (test_callback_fn
)allocation_test
},
5931 {"server_list_null_test", 0, (test_callback_fn
)server_list_null_test
},
5932 {"server_unsort", 0, (test_callback_fn
)server_unsort_test
},
5933 {"server_sort", 0, (test_callback_fn
)server_sort_test
},
5934 {"server_sort2", 0, (test_callback_fn
)server_sort2_test
},
5935 {"memcached_server_remove", 0, (test_callback_fn
)memcached_server_remove_test
},
5936 {"clone_test", 0, (test_callback_fn
)clone_test
},
5937 {"connection_test", 0, (test_callback_fn
)connection_test
},
5938 {"callback_test", 0, (test_callback_fn
)callback_test
},
5939 {"userdata_test", 0, (test_callback_fn
)userdata_test
},
5940 {"error", 0, (test_callback_fn
)error_test
},
5941 {"set", 0, (test_callback_fn
)set_test
},
5942 {"set2", 0, (test_callback_fn
)set_test2
},
5943 {"set3", 0, (test_callback_fn
)set_test3
},
5944 {"dump", 1, (test_callback_fn
)dump_test
},
5945 {"add", 1, (test_callback_fn
)add_test
},
5946 {"replace", 1, (test_callback_fn
)replace_test
},
5947 {"delete", 1, (test_callback_fn
)delete_test
},
5948 {"get", 1, (test_callback_fn
)get_test
},
5949 {"get2", 0, (test_callback_fn
)get_test2
},
5950 {"get3", 0, (test_callback_fn
)get_test3
},
5951 {"get4", 0, (test_callback_fn
)get_test4
},
5952 {"partial mget", 0, (test_callback_fn
)get_test5
},
5953 {"stats_servername", 0, (test_callback_fn
)stats_servername_test
},
5954 {"increment", 0, (test_callback_fn
)increment_test
},
5955 {"increment_with_initial", 1, (test_callback_fn
)increment_with_initial_test
},
5956 {"decrement", 0, (test_callback_fn
)decrement_test
},
5957 {"decrement_with_initial", 1, (test_callback_fn
)decrement_with_initial_test
},
5958 {"increment_by_key", 0, (test_callback_fn
)increment_by_key_test
},
5959 {"increment_with_initial_by_key", 1, (test_callback_fn
)increment_with_initial_by_key_test
},
5960 {"decrement_by_key", 0, (test_callback_fn
)decrement_by_key_test
},
5961 {"decrement_with_initial_by_key", 1, (test_callback_fn
)decrement_with_initial_by_key_test
},
5962 {"quit", 0, (test_callback_fn
)quit_test
},
5963 {"mget", 1, (test_callback_fn
)mget_test
},
5964 {"mget_result", 1, (test_callback_fn
)mget_result_test
},
5965 {"mget_result_alloc", 1, (test_callback_fn
)mget_result_alloc_test
},
5966 {"mget_result_function", 1, (test_callback_fn
)mget_result_function
},
5967 {"mget_execute", 1, (test_callback_fn
)mget_execute
},
5968 {"mget_end", 0, (test_callback_fn
)mget_end
},
5969 {"get_stats", 0, (test_callback_fn
)get_stats
},
5970 {"add_host_test", 0, (test_callback_fn
)add_host_test
},
5971 {"add_host_test_1", 0, (test_callback_fn
)add_host_test1
},
5972 {"get_stats_keys", 0, (test_callback_fn
)get_stats_keys
},
5973 {"version_string_test", 0, (test_callback_fn
)version_string_test
},
5974 {"bad_key", 1, (test_callback_fn
)bad_key_test
},
5975 {"memcached_server_cursor", 1, (test_callback_fn
)memcached_server_cursor_test
},
5976 {"read_through", 1, (test_callback_fn
)read_through
},
5977 {"delete_through", 1, (test_callback_fn
)delete_through
},
5978 {"noreply", 1, (test_callback_fn
)noreply_test
},
5979 {"analyzer", 1, (test_callback_fn
)analyzer_test
},
5980 #ifdef HAVE_LIBMEMCACHEDUTIL
5981 {"connectionpool", 1, (test_callback_fn
)connection_pool_test
},
5982 {"ping", 1, (test_callback_fn
)ping_test
},
5984 {"test_get_last_disconnect", 1, (test_callback_fn
)test_get_last_disconnect
},
5985 {"verbosity", 1, (test_callback_fn
)test_verbosity
},
5986 {"test_server_failure", 1, (test_callback_fn
)test_server_failure
},
5987 {"cull_servers", 1, (test_callback_fn
)test_cull_servers
},
5988 {"memcached_stat_execute", 1, (test_callback_fn
)memcached_stat_execute_test
},
5992 test_st behavior_tests
[] ={
5993 {"behavior_test", 0, (test_callback_fn
)behavior_test
},
5994 {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_CORK_test
},
5995 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5996 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
6000 test_st basic_tests
[] ={
6001 {"init", 1, (test_callback_fn
)basic_init_test
},
6002 {"clone", 1, (test_callback_fn
)basic_clone_test
},
6003 {"reset", 1, (test_callback_fn
)basic_reset_stack_test
},
6004 {"reset heap", 1, (test_callback_fn
)basic_reset_heap_test
},
6005 {"reset stack clone", 1, (test_callback_fn
)basic_reset_stack_clone_test
},
6006 {"reset heap clone", 1, (test_callback_fn
)basic_reset_heap_clone_test
},
6010 test_st regression_binary_vs_block
[] ={
6011 {"block add", 1, (test_callback_fn
)block_add_regression
},
6012 {"binary add", 1, (test_callback_fn
)binary_add_regression
},
6016 test_st async_tests
[] ={
6017 {"add", 1, (test_callback_fn
)add_wrapper
},
6021 test_st string_tests
[] ={
6022 {"string static with null", 0, (test_callback_fn
)string_static_null
},
6023 {"string alloc with null", 0, (test_callback_fn
)string_alloc_null
},
6024 {"string alloc with 1K", 0, (test_callback_fn
)string_alloc_with_size
},
6025 {"string alloc with malloc failure", 0, (test_callback_fn
)string_alloc_with_size_toobig
},
6026 {"string append", 0, (test_callback_fn
)string_alloc_append
},
6027 {"string append failure (too big)", 0, (test_callback_fn
)string_alloc_append_toobig
},
6028 {"string_alloc_append_multiple", 0, (test_callback_fn
)string_alloc_append_multiple
},
6029 {0, 0, (test_callback_fn
)0}
6032 test_st result_tests
[] ={
6033 {"result static", 0, (test_callback_fn
)result_static
},
6034 {"result alloc", 0, (test_callback_fn
)result_alloc
},
6035 {0, 0, (test_callback_fn
)0}
6038 test_st version_1_2_3
[] ={
6039 {"append", 0, (test_callback_fn
)append_test
},
6040 {"prepend", 0, (test_callback_fn
)prepend_test
},
6041 {"cas", 0, (test_callback_fn
)cas_test
},
6042 {"cas2", 0, (test_callback_fn
)cas2_test
},
6043 {"append_binary", 0, (test_callback_fn
)append_binary_test
},
6044 {0, 0, (test_callback_fn
)0}
6047 test_st user_tests
[] ={
6048 {"user_supplied_bug1", 0, (test_callback_fn
)user_supplied_bug1
},
6049 {"user_supplied_bug2", 0, (test_callback_fn
)user_supplied_bug2
},
6050 {"user_supplied_bug3", 0, (test_callback_fn
)user_supplied_bug3
},
6051 {"user_supplied_bug4", 0, (test_callback_fn
)user_supplied_bug4
},
6052 {"user_supplied_bug5", 1, (test_callback_fn
)user_supplied_bug5
},
6053 {"user_supplied_bug6", 1, (test_callback_fn
)user_supplied_bug6
},
6054 {"user_supplied_bug7", 1, (test_callback_fn
)user_supplied_bug7
},
6055 {"user_supplied_bug8", 1, (test_callback_fn
)user_supplied_bug8
},
6056 {"user_supplied_bug9", 1, (test_callback_fn
)user_supplied_bug9
},
6057 {"user_supplied_bug10", 1, (test_callback_fn
)user_supplied_bug10
},
6058 {"user_supplied_bug11", 1, (test_callback_fn
)user_supplied_bug11
},
6059 {"user_supplied_bug12", 1, (test_callback_fn
)user_supplied_bug12
},
6060 {"user_supplied_bug13", 1, (test_callback_fn
)user_supplied_bug13
},
6061 {"user_supplied_bug14", 1, (test_callback_fn
)user_supplied_bug14
},
6062 {"user_supplied_bug15", 1, (test_callback_fn
)user_supplied_bug15
},
6063 {"user_supplied_bug16", 1, (test_callback_fn
)user_supplied_bug16
},
6064 #if !defined(__sun) && !defined(__OpenBSD__)
6066 ** It seems to be something weird with the character sets..
6067 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6068 ** guess I need to find out how this is supposed to work.. Perhaps I need
6069 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6070 ** so just disable the code for now...).
6072 {"user_supplied_bug17", 1, (test_callback_fn
)user_supplied_bug17
},
6074 {"user_supplied_bug18", 1, (test_callback_fn
)user_supplied_bug18
},
6075 {"user_supplied_bug19", 1, (test_callback_fn
)user_supplied_bug19
},
6076 {"user_supplied_bug20", 1, (test_callback_fn
)user_supplied_bug20
},
6077 {"user_supplied_bug21", 1, (test_callback_fn
)user_supplied_bug21
},
6078 {"wrong_failure_counter_test", 1, (test_callback_fn
)wrong_failure_counter_test
},
6079 {"wrong_failure_counter_two_test", 1, (test_callback_fn
)wrong_failure_counter_two_test
},
6080 {0, 0, (test_callback_fn
)0}
6083 test_st replication_tests
[]= {
6084 {"set", 1, (test_callback_fn
)replication_set_test
},
6085 {"get", 0, (test_callback_fn
)replication_get_test
},
6086 {"mget", 0, (test_callback_fn
)replication_mget_test
},
6087 {"delete", 0, (test_callback_fn
)replication_delete_test
},
6088 {"rand_mget", 0, (test_callback_fn
)replication_randomize_mget_test
},
6089 {0, 0, (test_callback_fn
)0}
6093 * The following test suite is used to verify that we don't introduce
6094 * regression bugs. If you want more information about the bug / test,
6095 * you should look in the bug report at
6096 * http://bugs.launchpad.net/libmemcached
6098 test_st regression_tests
[]= {
6099 {"lp:434484", 1, (test_callback_fn
)regression_bug_434484
},
6100 {"lp:434843", 1, (test_callback_fn
)regression_bug_434843
},
6101 {"lp:434843-buffered", 1, (test_callback_fn
)regression_bug_434843_buffered
},
6102 {"lp:421108", 1, (test_callback_fn
)regression_bug_421108
},
6103 {"lp:442914", 1, (test_callback_fn
)regression_bug_442914
},
6104 {"lp:447342", 1, (test_callback_fn
)regression_bug_447342
},
6105 {"lp:463297", 1, (test_callback_fn
)regression_bug_463297
},
6106 {"lp:490486", 1, (test_callback_fn
)regression_bug_490486
},
6107 {"lp:583031", 1, (test_callback_fn
)regression_bug_583031
},
6108 {"lp:?", 1, (test_callback_fn
)regression_bug_
},
6109 {"lp:728286", 1, (test_callback_fn
)regression_bug_728286
},
6110 {"lp:581030", 1, (test_callback_fn
)regression_bug_581030
},
6111 {0, 0, (test_callback_fn
)0}
6114 test_st sasl_auth_tests
[]= {
6115 {"sasl_auth", 1, (test_callback_fn
)sasl_auth_test
},
6116 {0, 0, (test_callback_fn
)0}
6119 test_st ketama_compatibility
[]= {
6120 {"libmemcached", 1, (test_callback_fn
)ketama_compatibility_libmemcached
},
6121 {"spymemcached", 1, (test_callback_fn
)ketama_compatibility_spymemcached
},
6122 {0, 0, (test_callback_fn
)0}
6125 test_st generate_tests
[] ={
6126 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6127 {"generate_data", 1, (test_callback_fn
)generate_data
},
6128 {"get_read", 0, (test_callback_fn
)get_read
},
6129 {"delete_generate", 0, (test_callback_fn
)delete_generate
},
6130 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
6131 {"delete_buffer", 0, (test_callback_fn
)delete_buffer_generate
},
6132 {"generate_data", 1, (test_callback_fn
)generate_data
},
6133 {"mget_read", 0, (test_callback_fn
)mget_read
},
6134 {"mget_read_result", 0, (test_callback_fn
)mget_read_result
},
6135 {"mget_read_function", 0, (test_callback_fn
)mget_read_function
},
6136 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6137 {"generate_large_pairs", 1, (test_callback_fn
)generate_large_pairs
},
6138 {"generate_data", 1, (test_callback_fn
)generate_data
},
6139 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
6140 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6141 {0, 0, (test_callback_fn
)0}
6144 test_st consistent_tests
[] ={
6145 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6146 {"generate_data", 1, (test_callback_fn
)generate_data
},
6147 {"get_read", 0, (test_callback_fn
)get_read_count
},
6148 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6149 {0, 0, (test_callback_fn
)0}
6152 test_st consistent_weighted_tests
[] ={
6153 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6154 {"generate_data", 1, (test_callback_fn
)generate_data_with_stats
},
6155 {"get_read", 0, (test_callback_fn
)get_read_count
},
6156 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6157 {0, 0, (test_callback_fn
)0}
6160 test_st hsieh_availability
[] ={
6161 {"hsieh_avaibility_test", 0, (test_callback_fn
)hsieh_avaibility_test
},
6162 {0, 0, (test_callback_fn
)0}
6165 test_st murmur_availability
[] ={
6166 {"murmur_avaibility_test", 0, (test_callback_fn
)murmur_avaibility_test
},
6167 {0, 0, (test_callback_fn
)0}
6171 test_st hash_sanity
[] ={
6172 {"hash sanity", 0, (test_callback_fn
)hash_sanity_test
},
6173 {0, 0, (test_callback_fn
)0}
6177 test_st ketama_auto_eject_hosts
[] ={
6178 {"auto_eject_hosts", 1, (test_callback_fn
)auto_eject_hosts
},
6179 {"output_ketama_weighted_keys", 1, (test_callback_fn
)output_ketama_weighted_keys
},
6180 {0, 0, (test_callback_fn
)0}
6183 test_st hash_tests
[] ={
6184 {"one_at_a_time_run", 0, (test_callback_fn
)one_at_a_time_run
},
6185 {"md5", 0, (test_callback_fn
)md5_run
},
6186 {"crc", 0, (test_callback_fn
)crc_run
},
6187 {"fnv1_64", 0, (test_callback_fn
)fnv1_64_run
},
6188 {"fnv1a_64", 0, (test_callback_fn
)fnv1a_64_run
},
6189 {"fnv1_32", 0, (test_callback_fn
)fnv1_32_run
},
6190 {"fnv1a_32", 0, (test_callback_fn
)fnv1a_32_run
},
6191 {"hsieh", 0, (test_callback_fn
)hsieh_run
},
6192 {"murmur", 0, (test_callback_fn
)murmur_run
},
6193 {"jenkis", 0, (test_callback_fn
)jenkins_run
},
6194 {"memcached_get_hashkit", 0, (test_callback_fn
)memcached_get_hashkit_test
},
6195 {0, 0, (test_callback_fn
)0}
6198 test_st error_conditions
[] ={
6199 {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn
)memcached_get_MEMCACHED_ERRNO
},
6200 {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
)memcached_get_MEMCACHED_NOTFOUND
},
6201 {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn
)memcached_get_by_key_MEMCACHED_ERRNO
},
6202 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6203 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6204 {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn
)memcached_increment_MEMCACHED_NO_SERVERS
},
6205 {0, 0, (test_callback_fn
)0}
6209 test_st parser_tests
[] ={
6210 {"behavior", 0, (test_callback_fn
)behavior_parser_test
},
6211 {"boolean_options", 0, (test_callback_fn
)parser_boolean_options_test
},
6212 {"configure_file", 0, (test_callback_fn
)memcached_create_with_options_with_filename
},
6213 {"distribtions", 0, (test_callback_fn
)parser_distribution_test
},
6214 {"hash", 0, (test_callback_fn
)parser_hash_test
},
6215 {"libmemcached_check_configuration", 0, (test_callback_fn
)libmemcached_check_configuration_test
},
6216 {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn
)libmemcached_check_configuration_with_filename_test
},
6217 {"memcached_parse_configure_file", 0, (test_callback_fn
)memcached_parse_configure_file_test
},
6218 {"number_options", 0, (test_callback_fn
)parser_number_options_test
},
6219 {"randomly generated options", 0, (test_callback_fn
)random_statement_build_test
},
6220 {"prefix_key", 0, (test_callback_fn
)parser_key_prefix_test
},
6221 {"server", 0, (test_callback_fn
)server_test
},
6222 {"bad server strings", 0, (test_callback_fn
)servers_bad_test
},
6223 {"server with weights", 0, (test_callback_fn
)server_with_weight_test
},
6224 {0, 0, (test_callback_fn
)0}
6227 test_st virtual_bucket_tests
[] ={
6228 {"basic", 0, (test_callback_fn
)virtual_back_map
},
6229 {0, 0, (test_callback_fn
)0}
6232 collection_st collection
[] ={
6234 {"hash_sanity", 0, 0, hash_sanity
},
6236 {"basic", 0, 0, basic_tests
},
6237 {"hsieh_availability", 0, 0, hsieh_availability
},
6238 {"murmur_availability", 0, 0, murmur_availability
},
6239 {"block", 0, 0, tests
},
6240 {"binary", (test_callback_fn
)pre_binary
, 0, tests
},
6241 {"nonblock", (test_callback_fn
)pre_nonblock
, 0, tests
},
6242 {"nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6243 {"settimer", (test_callback_fn
)pre_settimer
, 0, tests
},
6244 {"md5", (test_callback_fn
)pre_md5
, 0, tests
},
6245 {"crc", (test_callback_fn
)pre_crc
, 0, tests
},
6246 {"hsieh", (test_callback_fn
)pre_hsieh
, 0, tests
},
6247 {"jenkins", (test_callback_fn
)pre_jenkins
, 0, tests
},
6248 {"fnv1_64", (test_callback_fn
)pre_hash_fnv1_64
, 0, tests
},
6249 {"fnv1a_64", (test_callback_fn
)pre_hash_fnv1a_64
, 0, tests
},
6250 {"fnv1_32", (test_callback_fn
)pre_hash_fnv1_32
, 0, tests
},
6251 {"fnv1a_32", (test_callback_fn
)pre_hash_fnv1a_32
, 0, tests
},
6252 {"ketama", (test_callback_fn
)pre_behavior_ketama
, 0, tests
},
6253 {"ketama_auto_eject_hosts", (test_callback_fn
)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6254 {"unix_socket", (test_callback_fn
)pre_unix_socket
, 0, tests
},
6255 {"unix_socket_nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6256 {"poll_timeout", (test_callback_fn
)poll_timeout
, 0, tests
},
6257 {"gets", (test_callback_fn
)enable_cas
, 0, tests
},
6258 {"consistent_crc", (test_callback_fn
)enable_consistent_crc
, 0, tests
},
6259 {"consistent_hsieh", (test_callback_fn
)enable_consistent_hsieh
, 0, tests
},
6260 #ifdef MEMCACHED_ENABLE_DEPRECATED
6261 {"deprecated_memory_allocators", (test_callback_fn
)deprecated_set_memory_alloc
, 0, tests
},
6263 {"memory_allocators", (test_callback_fn
)set_memory_alloc
, 0, tests
},
6264 {"prefix", (test_callback_fn
)set_prefix
, 0, tests
},
6265 {"sasl_auth", (test_callback_fn
)pre_sasl
, 0, sasl_auth_tests
},
6266 {"sasl", (test_callback_fn
)pre_sasl
, 0, tests
},
6267 {"version_1_2_3", (test_callback_fn
)check_for_1_2_3
, 0, version_1_2_3
},
6268 {"string", 0, 0, string_tests
},
6269 {"result", 0, 0, result_tests
},
6270 {"async", (test_callback_fn
)pre_nonblock
, 0, async_tests
},
6271 {"async_binary", (test_callback_fn
)pre_nonblock_binary
, 0, async_tests
},
6272 {"user", 0, 0, user_tests
},
6273 {"generate", 0, 0, generate_tests
},
6274 {"generate_hsieh", (test_callback_fn
)pre_hsieh
, 0, generate_tests
},
6275 {"generate_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, generate_tests
},
6276 {"generate_hsieh_consistent", (test_callback_fn
)enable_consistent_hsieh
, 0, generate_tests
},
6277 {"generate_md5", (test_callback_fn
)pre_md5
, 0, generate_tests
},
6278 {"generate_murmur", (test_callback_fn
)pre_murmur
, 0, generate_tests
},
6279 {"generate_jenkins", (test_callback_fn
)pre_jenkins
, 0, generate_tests
},
6280 {"generate_nonblock", (test_callback_fn
)pre_nonblock
, 0, generate_tests
},
6282 {"generate_corked", (test_callback_fn
)pre_cork
, 0, generate_tests
},
6283 {"generate_corked_and_nonblock", (test_callback_fn
)pre_cork_and_nonblock
, 0, generate_tests
},
6284 {"consistent_not", 0, 0, consistent_tests
},
6285 {"consistent_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, consistent_tests
},
6286 {"consistent_ketama_weighted", (test_callback_fn
)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6287 {"ketama_compat", 0, 0, ketama_compatibility
},
6288 {"test_hashes", 0, 0, hash_tests
},
6289 {"replication", (test_callback_fn
)pre_replication
, 0, replication_tests
},
6290 {"replication_noblock", (test_callback_fn
)pre_replication_noblock
, 0, replication_tests
},
6291 {"regression", 0, 0, regression_tests
},
6292 {"behaviors", 0, 0, behavior_tests
},
6293 {"regression_binary_vs_block", (test_callback_fn
)key_setup
, (test_callback_fn
)key_teardown
, regression_binary_vs_block
},
6294 {"error_conditions", 0, 0, error_conditions
},
6295 {"parser", 0, 0, parser_tests
},
6296 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6300 #define SERVERS_TO_CREATE 5
6302 #include "libmemcached_world.h"
6304 void get_world(world_st
*world
)
6306 world
->collections
= collection
;
6308 world
->create
= (test_callback_create_fn
)world_create
;
6309 world
->destroy
= (test_callback_fn
)world_destroy
;
6311 world
->test
.startup
= (test_callback_fn
)world_test_startup
;
6312 world
->test
.flush
= (test_callback_fn
)world_flush
;
6313 world
->test
.pre_run
= (test_callback_fn
)world_pre_run
;
6314 world
->test
.post_run
= (test_callback_fn
)world_post_run
;
6315 world
->test
.on_error
= (test_callback_error_fn
)world_on_error
;
6317 world
->collection
.startup
= (test_callback_fn
)world_container_startup
;
6318 world
->collection
.shutdown
= (test_callback_fn
)world_container_shutdown
;
6320 world
->runner
= &defualt_libmemcached_runner
;