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 if (! (test_ports
[x
] == server
->port
))
236 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
237 return MEMCACHED_FAILURE
;
240 *((uint32_t *)(context
))= ++x
;
242 return MEMCACHED_SUCCESS
;
245 static test_return_t
server_unsort_test(memcached_st
*ptr
)
247 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
248 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
249 memcached_return_t rc
;
250 memcached_server_fn callbacks
[1];
251 memcached_st
*local_memc
;
254 local_memc
= memcached_create(NULL
);
255 test_true(local_memc
);
257 for (size_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
259 test_ports
[x
]= (in_port_t
)(random() % 64000);
260 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
261 test_true(memcached_server_count(local_memc
) == x
+1);
263 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
265 test_true(rc
== MEMCACHED_SUCCESS
);
268 callbacks
[0]= server_display_unsort_function
;
269 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
271 /* Now we sort old data! */
272 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
273 callbacks
[0]= server_display_function
;
274 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
277 memcached_free(local_memc
);
282 static test_return_t
allocation_test(memcached_st
*not_used
)
286 memc
= memcached_create(NULL
);
288 memcached_free(memc
);
293 static test_return_t
clone_test(memcached_st
*memc
)
297 memcached_st
*memc_clone
;
298 memc_clone
= memcached_clone(NULL
, NULL
);
299 test_true(memc_clone
);
300 memcached_free(memc_clone
);
303 /* Can we init from null? */
305 memcached_st
*memc_clone
;
306 memc_clone
= memcached_clone(NULL
, memc
);
307 test_true(memc_clone
);
310 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
311 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
312 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
313 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
316 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
317 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
318 test_true(memc_clone
->distribution
== memc
->distribution
);
319 { // Test all of the flags
320 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
321 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
322 test_true(memc_clone
->flags
.reuse_memory
== memc
->flags
.reuse_memory
);
323 test_true(memc_clone
->flags
.use_cache_lookups
== memc
->flags
.use_cache_lookups
);
324 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
325 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
326 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
327 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
328 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
329 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
330 test_true(memc_clone
->flags
.hash_with_prefix_key
== memc
->flags
.hash_with_prefix_key
);
331 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
332 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
333 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
334 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
336 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
337 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
338 test_true(hashkit_compare(&memc_clone
->distribution_hashkit
, &memc
->distribution_hashkit
));
339 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
340 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
341 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
342 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
343 test_true(memc_clone
->on_clone
== memc
->on_clone
);
344 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
345 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
346 test_true(memc_clone
->recv_size
== memc
->recv_size
);
347 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
348 test_true(memc_clone
->send_size
== memc
->send_size
);
349 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
350 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
351 test_true(memc_clone
->user_data
== memc
->user_data
);
353 memcached_free(memc_clone
);
356 /* Can we init from struct? */
358 memcached_st declared_clone
;
359 memcached_st
*memc_clone
;
360 memset(&declared_clone
, 0 , sizeof(memcached_st
));
361 memc_clone
= memcached_clone(&declared_clone
, NULL
);
362 test_true(memc_clone
);
363 memcached_free(memc_clone
);
366 /* Can we init from struct? */
368 memcached_st declared_clone
;
369 memcached_st
*memc_clone
;
370 memset(&declared_clone
, 0 , sizeof(memcached_st
));
371 memc_clone
= memcached_clone(&declared_clone
, memc
);
372 test_true(memc_clone
);
373 memcached_free(memc_clone
);
379 static test_return_t
userdata_test(memcached_st
*memc
)
382 test_true(memcached_set_user_data(memc
, foo
) == NULL
);
383 test_true(memcached_get_user_data(memc
) == foo
);
384 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
389 static test_return_t
connection_test(memcached_st
*memc
)
391 memcached_return_t rc
;
393 rc
= memcached_server_add_with_weight(memc
, "localhost", 0, 0);
394 test_true(rc
== MEMCACHED_SUCCESS
);
399 static test_return_t
error_test(memcached_st
*memc
)
401 memcached_return_t rc
;
402 uint32_t values
[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U,
403 982370485U, 1263635348U, 4242906218U, 3829656100U,
404 1891735253U, 334139633U, 2257084983U, 3088286104U,
405 13199785U, 2542027183U, 1097051614U, 199566778U,
406 2748246961U, 2465192557U, 1664094137U, 2405439045U,
407 1842224848U, 692413798U, 3479807801U, 919913813U,
408 4269430871U, 610793021U, 527273862U, 1437122909U,
409 2300930706U, 2943759320U, 674306647U, 2400528935U,
410 54481931U, 4186304426U, 1741088401U, 2979625118U,
411 4159057246U, 3425930182U, 2593724503U, 1868899624U,
412 1769812374U, 2302537950U, 1110330676U, 3365377466U,
413 1336171666U, 3021258493U, 3365377466U };
415 // You have updated the memcache_error messages but not updated docs/tests.
416 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
419 const char *msg
= memcached_strerror(memc
, rc
);
420 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
421 MEMCACHED_HASH_JENKINS
);
422 if (values
[rc
] != hash_val
)
424 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the error_test\n");
425 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, rc
), hash_val
);
427 test_true(values
[rc
] == hash_val
);
429 test_true(MEMCACHED_MAXIMUM_RETURN
== 46);
434 static test_return_t
set_test(memcached_st
*memc
)
436 memcached_return_t rc
;
437 const char *key
= "foo";
438 const char *value
= "when we sanitize";
440 rc
= memcached_set(memc
, key
, strlen(key
),
441 value
, strlen(value
),
442 (time_t)0, (uint32_t)0);
443 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
448 static test_return_t
append_test(memcached_st
*memc
)
450 memcached_return_t rc
;
451 const char *key
= "fig";
452 const char *in_value
= "we";
453 char *out_value
= NULL
;
457 rc
= memcached_flush(memc
, 0);
458 test_true(rc
== MEMCACHED_SUCCESS
);
460 rc
= memcached_set(memc
, key
, strlen(key
),
461 in_value
, strlen(in_value
),
462 (time_t)0, (uint32_t)0);
463 test_true(rc
== MEMCACHED_SUCCESS
);
465 rc
= memcached_append(memc
, key
, strlen(key
),
466 " the", strlen(" the"),
467 (time_t)0, (uint32_t)0);
468 test_true(rc
== MEMCACHED_SUCCESS
);
470 rc
= memcached_append(memc
, key
, strlen(key
),
471 " people", strlen(" people"),
472 (time_t)0, (uint32_t)0);
473 test_true(rc
== MEMCACHED_SUCCESS
);
475 out_value
= memcached_get(memc
, key
, strlen(key
),
476 &value_length
, &flags
, &rc
);
477 test_true(!memcmp(out_value
, "we the people", strlen("we the people")));
478 test_true(strlen("we the people") == value_length
);
479 test_true(rc
== MEMCACHED_SUCCESS
);
485 static test_return_t
append_binary_test(memcached_st
*memc
)
487 memcached_return_t rc
;
488 const char *key
= "numbers";
489 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
495 rc
= memcached_flush(memc
, 0);
496 test_true(rc
== MEMCACHED_SUCCESS
);
498 rc
= memcached_set(memc
,
501 (time_t)0, (uint32_t)0);
502 test_true(rc
== MEMCACHED_SUCCESS
);
504 for (x
= 0; store_list
[x
] ; x
++)
506 rc
= memcached_append(memc
,
508 (char *)&store_list
[x
], sizeof(uint32_t),
509 (time_t)0, (uint32_t)0);
510 test_true(rc
== MEMCACHED_SUCCESS
);
513 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
514 &value_length
, &flags
, &rc
);
515 test_true((value_length
== (sizeof(uint32_t) * x
)));
516 test_true(rc
== MEMCACHED_SUCCESS
);
518 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
520 test_true(*ptr
== store_list
[x
- counter
]);
528 static test_return_t
cas2_test(memcached_st
*memc
)
530 memcached_return_t rc
;
531 const char *keys
[]= {"fudge", "son", "food"};
532 size_t key_length
[]= {5, 3, 4};
533 const char *value
= "we the people";
534 size_t value_length
= strlen("we the people");
536 memcached_result_st results_obj
;
537 memcached_result_st
*results
;
540 rc
= memcached_flush(memc
, 0);
541 test_true(rc
== MEMCACHED_SUCCESS
);
543 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
545 for (x
= 0; x
< 3; x
++)
547 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
548 keys
[x
], key_length
[x
],
549 (time_t)50, (uint32_t)9);
550 test_true(rc
== MEMCACHED_SUCCESS
);
553 rc
= memcached_mget(memc
, keys
, key_length
, 3);
555 results
= memcached_result_create(memc
, &results_obj
);
557 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
559 test_true(results
->item_cas
);
560 test_true(rc
== MEMCACHED_SUCCESS
);
561 test_true(memcached_result_cas(results
));
563 test_true(!memcmp(value
, "we the people", strlen("we the people")));
564 test_true(strlen("we the people") == value_length
);
565 test_true(rc
== MEMCACHED_SUCCESS
);
567 memcached_result_free(&results_obj
);
572 static test_return_t
cas_test(memcached_st
*memc
)
574 memcached_return_t rc
;
575 const char *key
= "fun";
576 size_t key_length
= strlen(key
);
577 const char *value
= "we the people";
578 const char* keys
[2] = { key
, NULL
};
579 size_t keylengths
[2] = { strlen(key
), 0 };
580 size_t value_length
= strlen(value
);
581 const char *value2
= "change the value";
582 size_t value2_length
= strlen(value2
);
584 memcached_result_st results_obj
;
585 memcached_result_st
*results
;
588 rc
= memcached_flush(memc
, 0);
589 test_true(rc
== MEMCACHED_SUCCESS
);
591 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
593 rc
= memcached_set(memc
, key
, strlen(key
),
594 value
, strlen(value
),
595 (time_t)0, (uint32_t)0);
596 test_true(rc
== MEMCACHED_SUCCESS
);
598 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
600 results
= memcached_result_create(memc
, &results_obj
);
602 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
604 test_true(rc
== MEMCACHED_SUCCESS
);
605 test_true(memcached_result_cas(results
));
606 test_true(!memcmp(value
, memcached_result_value(results
), value_length
));
607 test_true(strlen(memcached_result_value(results
)) == value_length
);
608 test_true(rc
== MEMCACHED_SUCCESS
);
609 uint64_t cas
= memcached_result_cas(results
);
612 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
613 test_true(rc
== MEMCACHED_END
);
614 test_true(results
== NULL
);
617 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
618 test_true(rc
== MEMCACHED_SUCCESS
);
621 * The item will have a new cas value, so try to set it again with the old
622 * value. This should fail!
624 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
625 test_true(rc
== MEMCACHED_DATA_EXISTS
);
627 memcached_result_free(&results_obj
);
632 static test_return_t
prepend_test(memcached_st
*memc
)
634 memcached_return_t rc
;
635 const char *key
= "fig";
636 const char *value
= "people";
637 char *out_value
= NULL
;
641 rc
= memcached_flush(memc
, 0);
642 test_true(rc
== MEMCACHED_SUCCESS
);
644 rc
= memcached_set(memc
, key
, strlen(key
),
645 value
, strlen(value
),
646 (time_t)0, (uint32_t)0);
647 test_true(rc
== MEMCACHED_SUCCESS
);
649 rc
= memcached_prepend(memc
, key
, strlen(key
),
650 "the ", strlen("the "),
651 (time_t)0, (uint32_t)0);
652 test_true(rc
== MEMCACHED_SUCCESS
);
654 rc
= memcached_prepend(memc
, key
, strlen(key
),
655 "we ", strlen("we "),
656 (time_t)0, (uint32_t)0);
657 test_true(rc
== MEMCACHED_SUCCESS
);
659 out_value
= memcached_get(memc
, key
, strlen(key
),
660 &value_length
, &flags
, &rc
);
661 test_true(!memcmp(out_value
, "we the people", strlen("we the people")));
662 test_true(strlen("we the people") == value_length
);
663 test_true(rc
== MEMCACHED_SUCCESS
);
670 Set the value, then quit to make sure it is flushed.
671 Come back in and test that add fails.
673 static test_return_t
add_test(memcached_st
*memc
)
675 memcached_return_t rc
;
676 const char *key
= "foo";
677 const char *value
= "when we sanitize";
678 unsigned long long setting_value
;
680 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
682 rc
= memcached_set(memc
, key
, strlen(key
),
683 value
, strlen(value
),
684 (time_t)0, (uint32_t)0);
685 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
686 memcached_quit(memc
);
687 rc
= memcached_add(memc
, key
, strlen(key
),
688 value
, strlen(value
),
689 (time_t)0, (uint32_t)0);
691 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
694 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
698 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
705 ** There was a problem of leaking filedescriptors in the initial release
706 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
707 ** systems it seems that the kernel is slow on reclaiming the resources
708 ** because the connects starts to time out (the test doesn't do much
709 ** anyway, so just loop 10 iterations)
711 static test_return_t
add_wrapper(memcached_st
*memc
)
713 unsigned int max
= 10000;
721 for (uint32_t x
= 0; x
< max
; x
++)
727 static test_return_t
replace_test(memcached_st
*memc
)
729 memcached_return_t rc
;
730 const char *key
= "foo";
731 const char *value
= "when we sanitize";
732 const char *original
= "first we insert some data";
734 rc
= memcached_set(memc
, key
, strlen(key
),
735 original
, strlen(original
),
736 (time_t)0, (uint32_t)0);
737 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
739 rc
= memcached_replace(memc
, key
, strlen(key
),
740 value
, strlen(value
),
741 (time_t)0, (uint32_t)0);
742 test_true(rc
== MEMCACHED_SUCCESS
);
747 static test_return_t
delete_test(memcached_st
*memc
)
749 memcached_return_t rc
;
750 const char *key
= "foo";
751 const char *value
= "when we sanitize";
753 rc
= memcached_set(memc
, key
, strlen(key
),
754 value
, strlen(value
),
755 (time_t)0, (uint32_t)0);
756 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
758 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
759 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
764 static test_return_t
flush_test(memcached_st
*memc
)
766 memcached_return_t rc
;
768 rc
= memcached_flush(memc
, 0);
769 test_true(rc
== MEMCACHED_SUCCESS
);
774 static memcached_return_t
server_function(const memcached_st
*ptr
,
775 const memcached_server_st
*server
,
778 (void)ptr
; (void)server
; (void)context
;
781 return MEMCACHED_SUCCESS
;
784 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
787 strncpy(context
, "foo bad", sizeof(context
));
788 memcached_server_fn callbacks
[1];
790 callbacks
[0]= server_function
;
791 memcached_server_cursor(memc
, callbacks
, context
, 1);
795 static test_return_t
bad_key_test(memcached_st
*memc
)
797 memcached_return_t rc
;
798 const char *key
= "foo bad";
800 size_t string_length
;
802 memcached_st
*memc_clone
;
804 size_t max_keylen
= 0xffff;
806 // Just skip if we are in binary mode.
807 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
810 memc_clone
= memcached_clone(NULL
, memc
);
811 test_true(memc_clone
);
813 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
814 test_true(rc
== MEMCACHED_SUCCESS
);
816 /* All keys are valid in the binary protocol (except for length) */
817 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 0)
819 string
= memcached_get(memc_clone
, key
, strlen(key
),
820 &string_length
, &flags
, &rc
);
821 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
822 test_true(string_length
== 0);
826 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
827 test_true(rc
== MEMCACHED_SUCCESS
);
828 string
= memcached_get(memc_clone
, key
, strlen(key
),
829 &string_length
, &flags
, &rc
);
830 test_true(rc
== MEMCACHED_NOTFOUND
);
831 test_true(string_length
== 0);
834 /* Test multi key for bad keys */
835 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
836 size_t key_lengths
[] = { 7, 7, 7 };
838 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
839 test_true(rc
== MEMCACHED_SUCCESS
);
841 rc
= memcached_mget(memc_clone
, keys
, key_lengths
, 3);
842 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
844 rc
= memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1);
845 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
849 /* The following test should be moved to the end of this function when the
850 memcached server is updated to allow max size length of the keys in the
853 rc
= memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
854 test_true(rc
== MEMCACHED_SUCCESS
);
856 char *longkey
= (char *)malloc(max_keylen
+ 1);
859 memset(longkey
, 'a', max_keylen
+ 1);
860 string
= memcached_get(memc_clone
, longkey
, max_keylen
,
861 &string_length
, &flags
, &rc
);
862 test_true(rc
== MEMCACHED_NOTFOUND
);
863 test_true(string_length
== 0);
866 string
= memcached_get(memc_clone
, longkey
, max_keylen
+ 1,
867 &string_length
, &flags
, &rc
);
868 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
869 test_true(string_length
== 0);
876 /* Make sure zero length keys are marked as bad */
878 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
879 test_true(rc
== MEMCACHED_SUCCESS
);
880 string
= memcached_get(memc_clone
, key
, 0,
881 &string_length
, &flags
, &rc
);
882 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
883 test_true(string_length
== 0);
886 memcached_free(memc_clone
);
891 #define READ_THROUGH_VALUE "set for me"
892 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
895 memcached_result_st
*result
)
897 (void)memc
;(void)key
;(void)key_length
;
898 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
901 static test_return_t
read_through(memcached_st
*memc
)
903 memcached_return_t rc
;
904 const char *key
= "foo";
906 size_t string_length
;
908 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
910 string
= memcached_get(memc
, key
, strlen(key
),
911 &string_length
, &flags
, &rc
);
913 test_true(rc
== MEMCACHED_NOTFOUND
);
914 test_false(string_length
);
917 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
,
919 test_true(rc
== MEMCACHED_SUCCESS
);
921 string
= memcached_get(memc
, key
, strlen(key
),
922 &string_length
, &flags
, &rc
);
924 test_true(rc
== MEMCACHED_SUCCESS
);
925 test_true(string_length
== strlen(READ_THROUGH_VALUE
));
926 test_strcmp(READ_THROUGH_VALUE
, string
);
929 string
= memcached_get(memc
, key
, strlen(key
),
930 &string_length
, &flags
, &rc
);
932 test_true(rc
== MEMCACHED_SUCCESS
);
933 test_true(string_length
== strlen(READ_THROUGH_VALUE
));
934 test_true(!strcmp(READ_THROUGH_VALUE
, string
));
940 static memcached_return_t
delete_trigger(memcached_st
*ptr
,
944 (void)ptr
;(void)key_length
;
947 return MEMCACHED_SUCCESS
;
950 static test_return_t
delete_through(memcached_st
*memc
)
952 memcached_trigger_delete_key_fn callback
;
953 memcached_return_t rc
;
955 callback
= (memcached_trigger_delete_key_fn
)delete_trigger
;
957 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
958 test_true(rc
== MEMCACHED_SUCCESS
);
963 static test_return_t
get_test(memcached_st
*memc
)
965 memcached_return_t rc
;
966 const char *key
= "foo";
968 size_t string_length
;
971 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
972 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
974 string
= memcached_get(memc
, key
, strlen(key
),
975 &string_length
, &flags
, &rc
);
977 test_true(rc
== MEMCACHED_NOTFOUND
);
978 test_false(string_length
);
984 static test_return_t
get_test2(memcached_st
*memc
)
986 memcached_return_t rc
;
987 const char *key
= "foo";
988 const char *value
= "when we sanitize";
990 size_t string_length
;
993 rc
= memcached_set(memc
, key
, strlen(key
),
994 value
, strlen(value
),
995 (time_t)0, (uint32_t)0);
996 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
998 string
= memcached_get(memc
, key
, strlen(key
),
999 &string_length
, &flags
, &rc
);
1002 test_true(rc
== MEMCACHED_SUCCESS
);
1003 test_true(string_length
== strlen(value
));
1004 test_true(!memcmp(string
, value
, string_length
));
1008 return TEST_SUCCESS
;
1011 static test_return_t
set_test2(memcached_st
*memc
)
1013 memcached_return_t rc
;
1014 const char *key
= "foo";
1015 const char *value
= "train in the brain";
1016 size_t value_length
= strlen(value
);
1019 for (x
= 0; x
< 10; x
++)
1021 rc
= memcached_set(memc
, key
, strlen(key
),
1022 value
, value_length
,
1023 (time_t)0, (uint32_t)0);
1024 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1027 return TEST_SUCCESS
;
1030 static test_return_t
set_test3(memcached_st
*memc
)
1032 memcached_return_t rc
;
1034 size_t value_length
= 8191;
1037 value
= (char*)malloc(value_length
);
1040 for (x
= 0; x
< value_length
; x
++)
1041 value
[x
] = (char) (x
% 127);
1043 /* The dump test relies on there being at least 32 items in memcached */
1044 for (x
= 0; x
< 32; x
++)
1048 snprintf(key
, sizeof(key
), "foo%u", x
);
1050 rc
= memcached_set(memc
, key
, strlen(key
),
1051 value
, value_length
,
1052 (time_t)0, (uint32_t)0);
1053 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1058 return TEST_SUCCESS
;
1061 static test_return_t
get_test3(memcached_st
*memc
)
1063 memcached_return_t rc
;
1064 const char *key
= "foo";
1066 size_t value_length
= 8191;
1068 size_t string_length
;
1072 value
= (char*)malloc(value_length
);
1075 for (x
= 0; x
< value_length
; x
++)
1076 value
[x
] = (char) (x
% 127);
1078 rc
= memcached_set(memc
, key
, strlen(key
),
1079 value
, value_length
,
1080 (time_t)0, (uint32_t)0);
1081 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1083 string
= memcached_get(memc
, key
, strlen(key
),
1084 &string_length
, &flags
, &rc
);
1086 test_true(rc
== MEMCACHED_SUCCESS
);
1088 test_true(string_length
== value_length
);
1089 test_true(!memcmp(string
, value
, string_length
));
1094 return TEST_SUCCESS
;
1097 static test_return_t
get_test4(memcached_st
*memc
)
1099 memcached_return_t rc
;
1100 const char *key
= "foo";
1102 size_t value_length
= 8191;
1104 size_t string_length
;
1108 value
= (char*)malloc(value_length
);
1111 for (x
= 0; x
< value_length
; x
++)
1112 value
[x
] = (char) (x
% 127);
1114 rc
= memcached_set(memc
, key
, strlen(key
),
1115 value
, value_length
,
1116 (time_t)0, (uint32_t)0);
1117 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1119 for (x
= 0; x
< 10; x
++)
1121 string
= memcached_get(memc
, key
, strlen(key
),
1122 &string_length
, &flags
, &rc
);
1124 test_true(rc
== MEMCACHED_SUCCESS
);
1126 test_true(string_length
== value_length
);
1127 test_true(!memcmp(string
, value
, string_length
));
1133 return TEST_SUCCESS
;
1137 * This test verifies that memcached_read_one_response doesn't try to
1138 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1139 * responses before you execute a storage command.
1141 static test_return_t
get_test5(memcached_st
*memc
)
1144 ** Request the same key twice, to ensure that we hash to the same server
1145 ** (so that we have multiple response values queued up) ;-)
1147 const char *keys
[]= { "key", "key" };
1148 size_t lengths
[]= { 3, 3 };
1152 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1153 keys
[0], lengths
[0], 0, 0);
1154 test_true(rc
== MEMCACHED_SUCCESS
);
1155 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1157 memcached_result_st results_obj
;
1158 memcached_result_st
*results
;
1159 results
=memcached_result_create(memc
, &results_obj
);
1161 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
1163 memcached_result_free(&results_obj
);
1165 /* Don't read out the second result, but issue a set instead.. */
1166 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
1167 test_true(rc
== MEMCACHED_SUCCESS
);
1169 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1170 &rlen
, &flags
, &rc
);
1171 test_true(val
== NULL
);
1172 test_true(rc
== MEMCACHED_NOTFOUND
);
1173 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1174 test_true(val
!= NULL
);
1175 test_true(rc
== MEMCACHED_SUCCESS
);
1178 return TEST_SUCCESS
;
1181 static test_return_t
mget_end(memcached_st
*memc
)
1183 const char *keys
[]= { "foo", "foo2" };
1184 size_t lengths
[]= { 3, 4 };
1185 const char *values
[]= { "fjord", "41" };
1187 memcached_return_t rc
;
1190 for (int i
= 0; i
< 2; i
++)
1192 rc
= memcached_set(memc
, keys
[i
], lengths
[i
], values
[i
], strlen(values
[i
]),
1193 (time_t)0, (uint32_t)0);
1194 test_true(rc
== MEMCACHED_SUCCESS
);
1198 size_t string_length
;
1201 // retrieve both via mget
1202 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1203 test_true(rc
== MEMCACHED_SUCCESS
);
1205 char key
[MEMCACHED_MAX_KEY
];
1208 // this should get both
1209 for (int i
= 0; i
< 2; i
++)
1211 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1213 test_true(rc
== MEMCACHED_SUCCESS
);
1215 if (key_length
== 4)
1217 test_true(string_length
== strlen(values
[val
]));
1218 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1222 // this should indicate end
1223 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1224 test_true(rc
== MEMCACHED_END
);
1227 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1228 test_true(rc
== MEMCACHED_SUCCESS
);
1230 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1231 test_true(key_length
== lengths
[0]);
1232 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1233 test_true(string_length
== strlen(values
[0]));
1234 test_true(strncmp(values
[0], string
, string_length
) == 0);
1235 test_true(rc
== MEMCACHED_SUCCESS
);
1238 // this should indicate end
1239 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1240 test_true(rc
== MEMCACHED_END
);
1242 return TEST_SUCCESS
;
1245 /* Do not copy the style of this code, I just access hosts to testthis function */
1246 static test_return_t
stats_servername_test(memcached_st
*memc
)
1248 memcached_return_t rc
;
1249 memcached_stat_st memc_stat
;
1250 memcached_server_instance_st instance
=
1251 memcached_server_instance_by_position(memc
, 0);
1253 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
1254 if (memcached_get_sasl_callbacks(memc
) != NULL
)
1255 return TEST_SKIPPED
;
1257 rc
= memcached_stat_servername(&memc_stat
, NULL
,
1258 memcached_server_name(instance
),
1259 memcached_server_port(instance
));
1261 return TEST_SUCCESS
;
1264 static test_return_t
increment_test(memcached_st
*memc
)
1266 uint64_t new_number
;
1267 memcached_return_t rc
;
1268 const char *key
= "number";
1269 const char *value
= "0";
1271 rc
= memcached_set(memc
, key
, strlen(key
),
1272 value
, strlen(value
),
1273 (time_t)0, (uint32_t)0);
1274 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1276 rc
= memcached_increment(memc
, key
, strlen(key
),
1278 test_true(rc
== MEMCACHED_SUCCESS
);
1279 test_true(new_number
== 1);
1281 rc
= memcached_increment(memc
, key
, strlen(key
),
1283 test_true(rc
== MEMCACHED_SUCCESS
);
1284 test_true(new_number
== 2);
1286 return TEST_SUCCESS
;
1289 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1291 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1293 uint64_t new_number
;
1294 memcached_return_t rc
;
1295 const char *key
= "number";
1296 uint64_t initial
= 0;
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
);
1303 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1304 1, initial
, 0, &new_number
);
1305 test_true(rc
== MEMCACHED_SUCCESS
);
1306 test_true(new_number
== (initial
+ 1));
1308 return TEST_SUCCESS
;
1311 static test_return_t
decrement_test(memcached_st
*memc
)
1313 uint64_t new_number
;
1314 memcached_return_t rc
;
1315 const char *key
= "number";
1316 const char *value
= "3";
1318 rc
= memcached_set(memc
, key
, strlen(key
),
1319 value
, strlen(value
),
1320 (time_t)0, (uint32_t)0);
1321 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1323 rc
= memcached_decrement(memc
, key
, strlen(key
),
1325 test_true(rc
== MEMCACHED_SUCCESS
);
1326 test_true(new_number
== 2);
1328 rc
= memcached_decrement(memc
, key
, strlen(key
),
1330 test_true(rc
== MEMCACHED_SUCCESS
);
1331 test_true(new_number
== 1);
1333 return TEST_SUCCESS
;
1336 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1338 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1340 uint64_t new_number
;
1341 memcached_return_t rc
;
1342 const char *key
= "number";
1343 uint64_t initial
= 3;
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
);
1350 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1351 1, initial
, 0, &new_number
);
1352 test_true(rc
== MEMCACHED_SUCCESS
);
1353 test_true(new_number
== (initial
- 1));
1355 return TEST_SUCCESS
;
1358 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1360 uint64_t new_number
;
1361 memcached_return_t rc
;
1362 const char *master_key
= "foo";
1363 const char *key
= "number";
1364 const char *value
= "0";
1366 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1368 value
, strlen(value
),
1369 (time_t)0, (uint32_t)0);
1370 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
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
== 1);
1377 rc
= memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1379 test_true(rc
== MEMCACHED_SUCCESS
);
1380 test_true(new_number
== 2);
1382 return TEST_SUCCESS
;
1385 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1387 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1389 uint64_t new_number
;
1390 memcached_return_t rc
;
1391 const char *master_key
= "foo";
1392 const char *key
= "number";
1393 uint64_t initial
= 0;
1395 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1397 1, initial
, 0, &new_number
);
1398 test_true(rc
== MEMCACHED_SUCCESS
);
1399 test_true(new_number
== initial
);
1401 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1403 1, initial
, 0, &new_number
);
1404 test_true(rc
== MEMCACHED_SUCCESS
);
1405 test_true(new_number
== (initial
+ 1));
1407 return TEST_SUCCESS
;
1410 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1412 uint64_t new_number
;
1413 memcached_return_t rc
;
1414 const char *master_key
= "foo";
1415 const char *key
= "number";
1416 const char *value
= "3";
1418 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1420 value
, strlen(value
),
1421 (time_t)0, (uint32_t)0);
1422 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1424 rc
= memcached_decrement_by_key(memc
, master_key
, strlen(master_key
),
1427 test_true(rc
== MEMCACHED_SUCCESS
);
1428 test_true(new_number
== 2);
1430 rc
= memcached_decrement_by_key(memc
, master_key
, strlen(master_key
),
1433 test_true(rc
== MEMCACHED_SUCCESS
);
1434 test_true(new_number
== 1);
1436 return TEST_SUCCESS
;
1439 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1441 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1443 uint64_t new_number
;
1444 memcached_return_t rc
;
1445 const char *master_key
= "foo";
1446 const char *key
= "number";
1447 uint64_t initial
= 3;
1449 rc
= memcached_decrement_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1451 1, initial
, 0, &new_number
);
1452 test_true(rc
== MEMCACHED_SUCCESS
);
1453 test_true(new_number
== initial
);
1455 rc
= memcached_decrement_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1457 1, initial
, 0, &new_number
);
1458 test_true(rc
== MEMCACHED_SUCCESS
);
1459 test_true(new_number
== (initial
- 1));
1461 return TEST_SUCCESS
;
1464 static test_return_t
quit_test(memcached_st
*memc
)
1466 memcached_return_t rc
;
1467 const char *key
= "fudge";
1468 const char *value
= "sanford and sun";
1470 rc
= memcached_set(memc
, key
, strlen(key
),
1471 value
, strlen(value
),
1472 (time_t)10, (uint32_t)3);
1473 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1474 memcached_quit(memc
);
1476 rc
= memcached_set(memc
, key
, strlen(key
),
1477 value
, strlen(value
),
1478 (time_t)50, (uint32_t)9);
1479 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1481 return TEST_SUCCESS
;
1484 static test_return_t
mget_result_test(memcached_st
*memc
)
1486 memcached_return_t rc
;
1487 const char *keys
[]= {"fudge", "son", "food"};
1488 size_t key_length
[]= {5, 3, 4};
1491 memcached_result_st results_obj
;
1492 memcached_result_st
*results
;
1494 results
= memcached_result_create(memc
, &results_obj
);
1496 test_true(&results_obj
== results
);
1498 /* We need to empty the server before continueing test */
1499 rc
= memcached_flush(memc
, 0);
1500 test_true(rc
== MEMCACHED_SUCCESS
);
1502 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1503 test_true(rc
== MEMCACHED_SUCCESS
);
1505 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1510 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1511 test_true(!results
);
1512 test_true(rc
== MEMCACHED_END
);
1514 for (x
= 0; x
< 3; x
++)
1516 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1517 keys
[x
], key_length
[x
],
1518 (time_t)50, (uint32_t)9);
1519 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1522 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1523 test_true(rc
== MEMCACHED_SUCCESS
);
1525 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1528 test_true(&results_obj
== results
);
1529 test_true(rc
== MEMCACHED_SUCCESS
);
1530 test_true(memcached_result_key_length(results
) == memcached_result_length(results
));
1531 test_true(!memcmp(memcached_result_key_value(results
),
1532 memcached_result_value(results
),
1533 memcached_result_length(results
)));
1536 memcached_result_free(&results_obj
);
1538 return TEST_SUCCESS
;
1541 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1543 memcached_return_t rc
;
1544 const char *keys
[]= {"fudge", "son", "food"};
1545 size_t key_length
[]= {5, 3, 4};
1548 memcached_result_st
*results
;
1550 /* We need to empty the server before continueing test */
1551 rc
= memcached_flush(memc
, 0);
1552 test_true(rc
== MEMCACHED_SUCCESS
);
1554 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1555 test_true(rc
== MEMCACHED_SUCCESS
);
1557 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
1561 test_true(!results
);
1562 test_true(rc
== MEMCACHED_END
);
1564 for (x
= 0; x
< 3; x
++)
1566 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1567 keys
[x
], key_length
[x
],
1568 (time_t)50, (uint32_t)9);
1569 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1572 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1573 test_true(rc
== MEMCACHED_SUCCESS
);
1576 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1579 test_true(rc
== MEMCACHED_SUCCESS
);
1580 test_true(memcached_result_key_length(results
) == memcached_result_length(results
));
1581 test_true(!memcmp(memcached_result_key_value(results
),
1582 memcached_result_value(results
),
1583 memcached_result_length(results
)));
1584 memcached_result_free(results
);
1588 return TEST_SUCCESS
;
1591 /* Count the results */
1592 static memcached_return_t
callback_counter(const memcached_st
*ptr
,
1593 memcached_result_st
*result
,
1596 (void)ptr
; (void)result
;
1597 size_t *counter
= (size_t *)context
;
1599 *counter
= *counter
+ 1;
1601 return MEMCACHED_SUCCESS
;
1604 static test_return_t
mget_result_function(memcached_st
*memc
)
1606 memcached_return_t rc
;
1607 const char *keys
[]= {"fudge", "son", "food"};
1608 size_t key_length
[]= {5, 3, 4};
1611 memcached_execute_fn callbacks
[1];
1613 /* We need to empty the server before continueing test */
1614 rc
= memcached_flush(memc
, 0);
1615 for (x
= 0; x
< 3; x
++)
1617 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1618 keys
[x
], key_length
[x
],
1619 (time_t)50, (uint32_t)9);
1620 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1623 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1624 test_true(rc
== MEMCACHED_SUCCESS
);
1626 callbacks
[0]= &callback_counter
;
1628 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1630 test_true(counter
== 3);
1632 return TEST_SUCCESS
;
1635 static test_return_t
mget_test(memcached_st
*memc
)
1637 memcached_return_t rc
;
1638 const char *keys
[]= {"fudge", "son", "food"};
1639 size_t key_length
[]= {5, 3, 4};
1643 char return_key
[MEMCACHED_MAX_KEY
];
1644 size_t return_key_length
;
1646 size_t return_value_length
;
1648 /* We need to empty the server before continueing test */
1649 rc
= memcached_flush(memc
, 0);
1650 test_true(rc
== MEMCACHED_SUCCESS
);
1652 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1653 test_true(rc
== MEMCACHED_SUCCESS
);
1655 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1656 &return_value_length
, &flags
, &rc
)) != NULL
)
1658 test_true(return_value
);
1660 test_true(!return_value
);
1661 test_true(return_value_length
== 0);
1662 test_true(rc
== MEMCACHED_END
);
1664 for (x
= 0; x
< 3; x
++)
1666 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1667 keys
[x
], key_length
[x
],
1668 (time_t)50, (uint32_t)9);
1669 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1672 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1673 test_true(rc
== MEMCACHED_SUCCESS
);
1676 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1677 &return_value_length
, &flags
, &rc
)))
1679 test_true(return_value
);
1680 test_true(rc
== MEMCACHED_SUCCESS
);
1681 test_true(return_key_length
== return_value_length
);
1682 test_true(!memcmp(return_value
, return_key
, return_value_length
));
1687 return TEST_SUCCESS
;
1690 static test_return_t
mget_execute(memcached_st
*memc
)
1694 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1698 * I only want to hit _one_ server so I know the number of requests I'm
1699 * sending in the pipeline.
1701 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1702 memc
->number_of_hosts
= 1;
1704 size_t max_keys
= 20480;
1707 char **keys
= calloc(max_keys
, sizeof(char*));
1708 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
1710 /* First add all of the items.. */
1711 char blob
[1024] = {0};
1712 memcached_return_t rc
;
1714 for (size_t x
= 0; x
< max_keys
; ++x
)
1718 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1720 test_true(keys
[x
] != NULL
);
1721 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1722 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1725 /* Try to get all of them with a large multiget */
1727 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
1728 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1729 max_keys
, callbacks
, &counter
, 1);
1731 if (rc
== MEMCACHED_SUCCESS
)
1734 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1735 test_true(rc
== MEMCACHED_END
);
1737 /* Verify that we got all of the items */
1738 test_true(counter
== max_keys
);
1740 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1742 test_true(counter
== 0);
1746 test_fail("note: this test functions differently when in binary mode");
1749 /* Release all allocated resources */
1750 for (size_t x
= 0; x
< max_keys
; ++x
)
1757 memc
->number_of_hosts
= number_of_hosts
;
1758 return TEST_SUCCESS
;
1761 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1763 static test_return_t
key_setup(memcached_st
*memc
)
1767 if (pre_binary(memc
) != TEST_SUCCESS
)
1768 return TEST_SKIPPED
;
1770 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1772 return TEST_SUCCESS
;
1775 static test_return_t
key_teardown(memcached_st
*memc
)
1778 pairs_free(global_pairs
);
1780 return TEST_SUCCESS
;
1783 static test_return_t
block_add_regression(memcached_st
*memc
)
1785 /* First add all of the items.. */
1786 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1788 memcached_return_t rc
;
1789 char blob
[1024] = {0};
1791 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1792 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1795 return TEST_SUCCESS
;
1798 static test_return_t
binary_add_regression(memcached_st
*memc
)
1800 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1801 test_return_t rc
= block_add_regression(memc
);
1802 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1806 static test_return_t
get_stats_keys(memcached_st
*memc
)
1810 memcached_stat_st memc_stat
;
1811 memcached_return_t rc
;
1813 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1814 test_true(rc
== MEMCACHED_SUCCESS
);
1815 for (ptr
= stat_list
; *ptr
; ptr
++)
1820 return TEST_SUCCESS
;
1823 static test_return_t
version_string_test(memcached_st
*memc
)
1825 const char *version_string
;
1828 version_string
= memcached_lib_version();
1830 test_true(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1832 return TEST_SUCCESS
;
1835 static test_return_t
get_stats(memcached_st
*memc
)
1839 memcached_return_t rc
;
1840 memcached_stat_st
*memc_stat
;
1842 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1843 test_true(rc
== MEMCACHED_SUCCESS
);
1845 test_true(rc
== MEMCACHED_SUCCESS
);
1846 test_true(memc_stat
);
1848 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1850 stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1851 test_true(rc
== MEMCACHED_SUCCESS
);
1852 for (ptr
= stat_list
; *ptr
; ptr
++);
1857 memcached_stat_free(NULL
, memc_stat
);
1859 return TEST_SUCCESS
;
1862 static test_return_t
add_host_test(memcached_st
*memc
)
1865 memcached_server_st
*servers
;
1866 memcached_return_t rc
;
1867 char servername
[]= "0.example.com";
1869 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1871 test_true(1 == memcached_server_list_count(servers
));
1873 for (x
= 2; x
< 20; x
++)
1875 char buffer
[SMALL_STRING_LEN
];
1877 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1878 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1880 test_true(rc
== MEMCACHED_SUCCESS
);
1881 test_true(x
== memcached_server_list_count(servers
));
1884 rc
= memcached_server_push(memc
, servers
);
1885 test_true(rc
== MEMCACHED_SUCCESS
);
1886 rc
= memcached_server_push(memc
, servers
);
1887 test_true(rc
== MEMCACHED_SUCCESS
);
1889 memcached_server_list_free(servers
);
1891 return TEST_SUCCESS
;
1894 static memcached_return_t
clone_test_callback(memcached_st
*parent
, memcached_st
*memc_clone
)
1896 (void)parent
;(void)memc_clone
;
1897 return MEMCACHED_SUCCESS
;
1900 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
)
1903 return MEMCACHED_SUCCESS
;
1906 static test_return_t
callback_test(memcached_st
*memc
)
1908 /* Test User Data */
1912 memcached_return_t rc
;
1914 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1915 test_true(rc
== MEMCACHED_SUCCESS
);
1916 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1917 test_true(*test_ptr
== x
);
1920 /* Test Clone Callback */
1922 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1923 void *clone_cb_ptr
= *(void **)&clone_cb
;
1924 void *temp_function
= NULL
;
1925 memcached_return_t rc
;
1927 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1929 test_true(rc
== MEMCACHED_SUCCESS
);
1930 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1931 test_true(temp_function
== clone_cb_ptr
);
1934 /* Test Cleanup Callback */
1936 memcached_cleanup_fn cleanup_cb
=
1937 (memcached_cleanup_fn
)cleanup_test_callback
;
1938 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1939 void *temp_function
= NULL
;
1940 memcached_return_t rc
;
1942 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1944 test_true(rc
== MEMCACHED_SUCCESS
);
1945 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1946 test_true(temp_function
== cleanup_cb_ptr
);
1949 return TEST_SUCCESS
;
1952 /* We don't test the behavior itself, we test the switches */
1953 static test_return_t
behavior_test(memcached_st
*memc
)
1958 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1959 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1960 test_true(value
== 1);
1962 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1963 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1964 test_true(value
== 1);
1966 set
= MEMCACHED_HASH_MD5
;
1967 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1968 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1969 test_true(value
== MEMCACHED_HASH_MD5
);
1973 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1974 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1975 test_true(value
== 0);
1977 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1978 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1979 test_true(value
== 0);
1981 set
= MEMCACHED_HASH_DEFAULT
;
1982 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1983 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1984 test_true(value
== MEMCACHED_HASH_DEFAULT
);
1986 set
= MEMCACHED_HASH_CRC
;
1987 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1988 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1989 test_true(value
== MEMCACHED_HASH_CRC
);
1991 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1992 test_true(value
> 0);
1994 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1995 test_true(value
> 0);
1997 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
1998 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
1999 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2001 return TEST_SUCCESS
;
2004 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2006 memcached_return_t rc
;
2009 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
2010 test_true(rc
== MEMCACHED_DEPRECATED
);
2012 // Platform dependent
2014 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2018 return TEST_SUCCESS
;
2022 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2024 memcached_return_t rc
;
2028 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, set
);
2029 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2031 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2033 if (rc
== MEMCACHED_SUCCESS
)
2035 test_true((bool)value
== set
);
2039 test_false((bool)value
== set
);
2042 return TEST_SUCCESS
;
2046 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2048 memcached_return_t rc
;
2052 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, set
);
2053 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2055 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2057 if (rc
== MEMCACHED_SUCCESS
)
2059 test_true((bool)value
== set
);
2063 test_false((bool)value
== set
);
2066 return TEST_SUCCESS
;
2069 static test_return_t
fetch_all_results(memcached_st
*memc
, size_t *keys_returned
)
2071 memcached_return_t rc
= MEMCACHED_SUCCESS
;
2072 char return_key
[MEMCACHED_MAX_KEY
];
2073 size_t return_key_length
;
2075 size_t return_value_length
;
2080 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2081 &return_value_length
, &flags
, &rc
)))
2083 test_true(return_value
);
2084 test_true(rc
== MEMCACHED_SUCCESS
);
2086 *keys_returned
= *keys_returned
+1;
2089 test_true_got(rc
== MEMCACHED_END
|| rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
2091 return TEST_SUCCESS
;
2094 /* Test case provided by Cal Haldenbrand */
2095 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2097 unsigned int setter
= 1;
2099 unsigned long long total
= 0;
2102 char randomstuff
[6 * 1024];
2103 memcached_return_t rc
;
2105 memset(randomstuff
, 0, 6 * 1024);
2107 /* We just keep looking at the same values over and over */
2110 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2111 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2115 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2119 size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2120 memset(randomstuff
, 0, 6 * 1024);
2121 test_true(size
< 6 * 1024); /* Being safe here */
2123 for (j
= 0 ; j
< size
;j
++)
2124 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2127 snprintf(key
, sizeof(key
), "%u", x
);
2128 rc
= memcached_set(memc
, key
, strlen(key
),
2129 randomstuff
, strlen(randomstuff
), 10, 0);
2130 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2131 /* If we fail, lets try again */
2132 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
2133 rc
= memcached_set(memc
, key
, strlen(key
),
2134 randomstuff
, strlen(randomstuff
), 10, 0);
2135 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2138 return TEST_SUCCESS
;
2141 /* Test case provided by Cal Haldenbrand */
2142 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2144 unsigned int setter
;
2148 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2149 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2151 setter
= 20 * 1024576;
2152 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2153 setter
= 20 * 1024576;
2154 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2155 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2156 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2158 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2161 for (uint32_t x
= 0, errors
= 0; total
< 24576 ; x
++)
2163 memcached_return_t rc
= MEMCACHED_SUCCESS
;
2164 char buffer
[SMALL_STRING_LEN
];
2169 memset(buffer
, 0, SMALL_STRING_LEN
);
2171 snprintf(buffer
, sizeof(buffer
), "%u", x
);
2172 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
2173 &val_len
, &flags
, &rc
);
2174 if (rc
!= MEMCACHED_SUCCESS
)
2176 if (rc
== MEMCACHED_NOTFOUND
)
2190 return TEST_SUCCESS
;
2193 /* Do a large mget() over all the keys we think exist */
2194 #define KEY_COUNT 3000 // * 1024576
2195 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2197 memcached_return_t rc
;
2198 unsigned int setter
;
2201 size_t key_lengths
[KEY_COUNT
];
2204 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2205 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2207 setter
= 20 * 1024576;
2208 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2209 setter
= 20 * 1024576;
2210 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2211 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2212 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2215 keys
= calloc(KEY_COUNT
, sizeof(char *));
2217 for (x
= 0; x
< KEY_COUNT
; x
++)
2221 snprintf(buffer
, 30, "%u", x
);
2222 keys
[x
]= strdup(buffer
);
2223 key_lengths
[x
]= strlen(keys
[x
]);
2226 rc
= memcached_mget(memc
, (const char **)keys
, key_lengths
, KEY_COUNT
);
2227 test_true(rc
== MEMCACHED_SUCCESS
);
2229 size_t keys_returned
;
2230 test_true(fetch_all_results(memc
, &keys_returned
) == TEST_SUCCESS
);
2232 for (x
= 0; x
< KEY_COUNT
; x
++)
2236 return TEST_SUCCESS
;
2239 /* Make sure we behave properly if server list has no values */
2240 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2242 memcached_return_t rc
;
2243 const char *keys
[]= {"fudge", "son", "food"};
2244 size_t key_length
[]= {5, 3, 4};
2247 char return_key
[MEMCACHED_MAX_KEY
];
2248 size_t return_key_length
;
2250 size_t return_value_length
;
2252 /* Here we free everything before running a bunch of mget tests */
2253 memcached_servers_reset(memc
);
2256 /* We need to empty the server before continueing test */
2257 rc
= memcached_flush(memc
, 0);
2258 test_true(rc
== MEMCACHED_NO_SERVERS
);
2260 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2261 test_true(rc
== MEMCACHED_NO_SERVERS
);
2263 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2264 &return_value_length
, &flags
, &rc
)) != NULL
)
2266 test_true(return_value
);
2268 test_true(!return_value
);
2269 test_true(return_value_length
== 0);
2270 test_true(rc
== MEMCACHED_NO_SERVERS
);
2272 for (x
= 0; x
< 3; x
++)
2274 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2275 keys
[x
], key_length
[x
],
2276 (time_t)50, (uint32_t)9);
2277 test_true(rc
== MEMCACHED_NO_SERVERS
);
2280 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2281 test_true(rc
== MEMCACHED_NO_SERVERS
);
2284 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2285 &return_value_length
, &flags
, &rc
)))
2287 test_true(return_value
);
2288 test_true(rc
== MEMCACHED_SUCCESS
);
2289 test_true(return_key_length
== return_value_length
);
2290 test_true(!memcmp(return_value
, return_key
, return_value_length
));
2295 return TEST_SUCCESS
;
2298 #define VALUE_SIZE_BUG5 1048064
2299 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2301 memcached_return_t rc
;
2302 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2303 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2304 char return_key
[MEMCACHED_MAX_KEY
];
2305 size_t return_key_length
;
2307 size_t value_length
;
2311 char insert_data
[VALUE_SIZE_BUG5
];
2313 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2314 insert_data
[x
]= (signed char)rand();
2316 memcached_flush(memc
, 0);
2317 value
= memcached_get(memc
, keys
[0], key_length
[0],
2318 &value_length
, &flags
, &rc
);
2319 test_true(value
== NULL
);
2320 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2323 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2324 &value_length
, &flags
, &rc
)))
2326 test_true(count
== 0);
2328 for (x
= 0; x
< 4; x
++)
2330 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2331 insert_data
, VALUE_SIZE_BUG5
,
2332 (time_t)0, (uint32_t)0);
2333 test_true(rc
== MEMCACHED_SUCCESS
);
2336 for (x
= 0; x
< 10; x
++)
2338 value
= memcached_get(memc
, keys
[0], key_length
[0],
2339 &value_length
, &flags
, &rc
);
2343 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2345 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2346 &value_length
, &flags
, &rc
)))
2351 test_true(count
== 4);
2354 return TEST_SUCCESS
;
2357 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2359 memcached_return_t rc
;
2360 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2361 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2362 char return_key
[MEMCACHED_MAX_KEY
];
2363 size_t return_key_length
;
2365 size_t value_length
;
2369 char insert_data
[VALUE_SIZE_BUG5
];
2371 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2372 insert_data
[x
]= (signed char)rand();
2374 memcached_flush(memc
, 0);
2375 value
= memcached_get(memc
, keys
[0], key_length
[0],
2376 &value_length
, &flags
, &rc
);
2377 test_true(value
== NULL
);
2378 test_true(rc
== MEMCACHED_NOTFOUND
);
2379 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2380 test_true(rc
== MEMCACHED_SUCCESS
);
2383 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2384 &value_length
, &flags
, &rc
)))
2386 test_true(count
== 0);
2387 test_true(rc
== MEMCACHED_END
);
2389 for (x
= 0; x
< 4; x
++)
2391 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2392 insert_data
, VALUE_SIZE_BUG5
,
2393 (time_t)0, (uint32_t)0);
2394 test_true(rc
== MEMCACHED_SUCCESS
);
2397 for (x
= 0; x
< 2; x
++)
2399 value
= memcached_get(memc
, keys
[0], key_length
[0],
2400 &value_length
, &flags
, &rc
);
2404 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2405 test_true(rc
== MEMCACHED_SUCCESS
);
2407 /* We test for purge of partial complete fetches */
2408 for (count
= 3; count
; count
--)
2410 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2411 &value_length
, &flags
, &rc
);
2412 test_true(rc
== MEMCACHED_SUCCESS
);
2413 test_true(!(memcmp(value
, insert_data
, value_length
)));
2414 test_true(value_length
);
2419 return TEST_SUCCESS
;
2422 static test_return_t
user_supplied_bug8(memcached_st
*memc
)
2424 memcached_return_t rc
;
2426 memcached_st
*memc_clone
;
2428 memcached_server_st
*servers
;
2429 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";
2432 servers
= memcached_servers_parse(server_list
);
2435 mine
= memcached_create(NULL
);
2436 rc
= memcached_server_push(mine
, servers
);
2437 test_true(rc
== MEMCACHED_SUCCESS
);
2438 memcached_server_list_free(servers
);
2441 memc_clone
= memcached_clone(NULL
, mine
);
2443 memcached_quit(mine
);
2444 memcached_quit(memc_clone
);
2447 memcached_free(mine
);
2448 memcached_free(memc_clone
);
2450 return TEST_SUCCESS
;
2453 /* Test flag store/retrieve */
2454 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2456 memcached_return_t rc
;
2457 const char *keys
= "036790384900";
2458 size_t key_length
= strlen(keys
);
2459 char return_key
[MEMCACHED_MAX_KEY
];
2460 size_t return_key_length
;
2462 size_t value_length
;
2465 char insert_data
[VALUE_SIZE_BUG5
];
2467 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2468 insert_data
[x
]= (signed char)rand();
2470 memcached_flush(memc
, 0);
2473 rc
= memcached_set(memc
, keys
, key_length
,
2474 insert_data
, VALUE_SIZE_BUG5
,
2476 test_true(rc
== MEMCACHED_SUCCESS
);
2479 value
= memcached_get(memc
, keys
, key_length
,
2480 &value_length
, &flags
, &rc
);
2481 test_true(flags
== 245);
2485 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2488 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2489 &value_length
, &flags
, &rc
);
2490 test_true(flags
== 245);
2495 return TEST_SUCCESS
;
2498 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2500 memcached_return_t rc
;
2501 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2502 size_t key_length
[3];
2507 char return_key
[MEMCACHED_MAX_KEY
];
2508 size_t return_key_length
;
2510 size_t return_value_length
;
2513 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2514 key_length
[1]= strlen("fudge&*@#");
2515 key_length
[2]= strlen("for^#@&$not");
2518 for (x
= 0; x
< 3; x
++)
2520 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2521 keys
[x
], key_length
[x
],
2522 (time_t)50, (uint32_t)9);
2523 test_true(rc
== MEMCACHED_SUCCESS
);
2526 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2527 test_true(rc
== MEMCACHED_SUCCESS
);
2529 /* We need to empty the server before continueing test */
2530 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2531 &return_value_length
, &flags
, &rc
)) != NULL
)
2533 test_true(return_value
);
2537 test_true(count
== 3);
2539 return TEST_SUCCESS
;
2542 /* We are testing with aggressive timeout to get failures */
2543 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2545 const char *key
= "foo";
2547 size_t value_length
= 512;
2550 memcached_return_t rc
;
2551 unsigned int set
= 1;
2552 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2555 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2556 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2558 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2561 value
= (char*)malloc(value_length
* sizeof(char));
2563 for (x
= 0; x
< value_length
; x
++)
2564 value
[x
]= (char) (x
% 127);
2566 for (x
= 1; x
<= 100000; ++x
)
2568 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2570 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2571 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2573 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2578 memcached_free(mclone
);
2580 return TEST_SUCCESS
;
2584 We are looking failures in the async protocol
2586 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2588 const char *key
= "foo";
2590 size_t value_length
= 512;
2593 memcached_return_t rc
;
2594 unsigned int set
= 1;
2596 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2598 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2599 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2601 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2604 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2606 test_true(timeout
== -1);
2608 value
= (char*)malloc(value_length
* sizeof(char));
2610 for (x
= 0; x
< value_length
; x
++)
2611 value
[x
]= (char) (x
% 127);
2613 for (x
= 1; x
<= 100000; ++x
)
2615 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2619 memcached_free(mclone
);
2621 return TEST_SUCCESS
;
2625 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2627 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2629 memcached_return_t rc
;
2631 size_t value_length
;
2633 uint64_t number_value
;
2635 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2636 &value_length
, &flags
, &rc
);
2637 test_true(value
== NULL
);
2638 test_true(rc
== MEMCACHED_NOTFOUND
);
2640 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2643 test_true(value
== NULL
);
2644 /* The binary protocol will set the key if it doesn't exist */
2645 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2647 test_true(rc
== MEMCACHED_SUCCESS
);
2651 test_true(rc
== MEMCACHED_NOTFOUND
);
2654 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2656 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2657 &value_length
, &flags
, &rc
);
2659 test_true(rc
== MEMCACHED_SUCCESS
);
2662 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2664 test_true(number_value
== 2);
2665 test_true(rc
== MEMCACHED_SUCCESS
);
2667 return TEST_SUCCESS
;
2671 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2672 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2674 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2676 char key
[] = "key34567890";
2678 memcached_return_t rc
;
2679 size_t overflowSize
;
2681 char commandFirst
[]= "set key34567890 0 0 ";
2682 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2683 size_t commandLength
;
2686 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2688 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2690 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2692 overflow
= malloc(testSize
);
2693 test_true(overflow
!= NULL
);
2695 memset(overflow
, 'x', testSize
);
2696 rc
= memcached_set(memc
, key
, strlen(key
),
2697 overflow
, testSize
, 0, 0);
2698 test_true(rc
== MEMCACHED_SUCCESS
);
2702 return TEST_SUCCESS
;
2707 Test values of many different sizes
2708 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2709 set key34567890 0 0 8169 \r\n
2710 is sent followed by buffer of size 8169, followed by 8169
2712 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2715 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2716 memcached_return_t rc
;
2717 const char *key
= "foo";
2719 size_t value_length
= 18000;
2721 size_t string_length
;
2724 size_t current_length
;
2726 value
= (char*)malloc(value_length
);
2729 for (x
= 0; x
< value_length
; x
++)
2730 value
[x
] = (char) (x
% 127);
2732 for (current_length
= 0; current_length
< value_length
; current_length
++)
2734 rc
= memcached_set(memc
, key
, strlen(key
),
2735 value
, current_length
,
2736 (time_t)0, (uint32_t)0);
2737 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2739 string
= memcached_get(memc
, key
, strlen(key
),
2740 &string_length
, &flags
, &rc
);
2742 test_true(rc
== MEMCACHED_SUCCESS
);
2743 test_true(string_length
== current_length
);
2744 test_true(!memcmp(string
, value
, string_length
));
2751 return TEST_SUCCESS
;
2755 Look for zero length value problems
2757 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2760 memcached_return_t rc
;
2761 const char *key
= "mykey";
2766 for (x
= 0; x
< 2; x
++)
2768 rc
= memcached_set(memc
, key
, strlen(key
),
2770 (time_t)0, (uint32_t)0);
2772 test_true(rc
== MEMCACHED_SUCCESS
);
2774 value
= memcached_get(memc
, key
, strlen(key
),
2775 &length
, &flags
, &rc
);
2777 test_true(rc
== MEMCACHED_SUCCESS
);
2778 test_true(value
== NULL
);
2779 test_true(length
== 0);
2780 test_true(flags
== 0);
2782 value
= memcached_get(memc
, key
, strlen(key
),
2783 &length
, &flags
, &rc
);
2785 test_true(rc
== MEMCACHED_SUCCESS
);
2786 test_true(value
== NULL
);
2787 test_true(length
== 0);
2788 test_true(flags
== 0);
2791 return TEST_SUCCESS
;
2794 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2795 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2797 memcached_return_t rc
;
2798 const char *key
= "mykey";
2803 rc
= memcached_set(memc
, key
, strlen(key
),
2805 (time_t)0, UINT32_MAX
);
2807 test_true(rc
== MEMCACHED_SUCCESS
);
2809 value
= memcached_get(memc
, key
, strlen(key
),
2810 &length
, &flags
, &rc
);
2812 test_true(rc
== MEMCACHED_SUCCESS
);
2813 test_true(value
== NULL
);
2814 test_true(length
== 0);
2815 test_true(flags
== UINT32_MAX
);
2817 return TEST_SUCCESS
;
2820 #if !defined(__sun) && !defined(__OpenBSD__)
2821 /* Check the validity of chinese key*/
2822 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2824 memcached_return_t rc
;
2825 const char *key
= "豆瓣";
2826 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2831 rc
= memcached_set(memc
, key
, strlen(key
),
2832 value
, strlen(value
),
2835 test_true(rc
== MEMCACHED_SUCCESS
);
2837 value2
= memcached_get(memc
, key
, strlen(key
),
2838 &length
, &flags
, &rc
);
2840 test_true(length
==strlen(value
));
2841 test_true(rc
== MEMCACHED_SUCCESS
);
2842 test_true(memcmp(value
, value2
, length
)==0);
2845 return TEST_SUCCESS
;
2853 static test_return_t
user_supplied_bug19(memcached_st
*not_used
)
2856 const memcached_server_st
*server
;
2857 memcached_return_t res
;
2861 memc
= memcached_create(NULL
);
2862 memcached_server_add_with_weight(memc
, "localhost", 11311, 100);
2863 memcached_server_add_with_weight(memc
, "localhost", 11312, 100);
2865 server
= memcached_server_by_key(memc
, "a", 1, &res
);
2867 memcached_free(memc
);
2869 return TEST_SUCCESS
;
2872 /* CAS test from Andei */
2873 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2875 memcached_return_t status
;
2876 memcached_result_st
*result
, result_obj
;
2877 const char *key
= "abc";
2878 size_t key_len
= strlen("abc");
2879 const char *value
= "foobar";
2880 size_t value_len
= strlen(value
);
2882 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2884 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2885 test_true(status
== MEMCACHED_SUCCESS
);
2887 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2888 test_true(status
== MEMCACHED_SUCCESS
);
2890 result
= memcached_result_create(memc
, &result_obj
);
2893 memcached_result_create(memc
, &result_obj
);
2894 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2897 test_true(status
== MEMCACHED_SUCCESS
);
2899 memcached_result_free(result
);
2901 return TEST_SUCCESS
;
2904 #include "ketama_test_cases.h"
2905 static test_return_t
user_supplied_bug18(memcached_st
*trash
)
2907 memcached_return_t rc
;
2910 memcached_server_st
*server_pool
;
2915 memc
= memcached_create(NULL
);
2918 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2919 test_true(rc
== MEMCACHED_SUCCESS
);
2921 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2922 test_true(value
== 1);
2924 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2925 test_true(rc
== MEMCACHED_SUCCESS
);
2927 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2928 test_true(value
== MEMCACHED_HASH_MD5
);
2930 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");
2931 memcached_server_push(memc
, server_pool
);
2933 /* verify that the server list was parsed okay. */
2934 test_true(memcached_server_count(memc
) == 8);
2935 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2936 test_true(server_pool
[0].port
== 11211);
2937 test_true(server_pool
[0].weight
== 600);
2938 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2939 test_true(server_pool
[2].port
== 11211);
2940 test_true(server_pool
[2].weight
== 200);
2941 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2942 test_true(server_pool
[7].port
== 11211);
2943 test_true(server_pool
[7].weight
== 100);
2945 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2946 * us test the boundary wraparound.
2948 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
2950 /* verify the standard ketama set. */
2951 for (x
= 0; x
< 99; x
++)
2953 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2955 memcached_server_instance_st instance
=
2956 memcached_server_instance_by_position(memc
, server_idx
);
2958 const char *hostname
= memcached_server_name(instance
);
2959 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
2962 memcached_server_list_free(server_pool
);
2963 memcached_free(memc
);
2965 return TEST_SUCCESS
;
2968 /* Large mget() of missing keys with binary proto
2970 * If many binary quiet commands (such as getq's in an mget) fill the output
2971 * buffer and the server chooses not to respond, memcached_flush hangs. See
2972 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2975 /* sighandler_t function that always asserts false */
2976 static void fail(int unused
)
2983 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2988 return TEST_SKIPPED
;
2990 memcached_return_t rc
;
2993 size_t* key_lengths
;
2994 void (*oldalarm
)(int);
2995 memcached_st
*memc_clone
;
2997 memc_clone
= memcached_clone(NULL
, memc
);
2998 test_true(memc_clone
);
3000 /* only binproto uses getq for mget */
3001 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3003 /* empty the cache to ensure misses (hence non-responses) */
3004 rc
= memcached_flush(memc_clone
, 0);
3005 test_true(rc
== MEMCACHED_SUCCESS
);
3007 key_lengths
= calloc(key_count
, sizeof(size_t));
3008 keys
= calloc(key_count
, sizeof(char *));
3010 for (x
= 0; x
< key_count
; x
++)
3014 snprintf(buffer
, 30, "%u", x
);
3015 keys
[x
]= strdup(buffer
);
3016 key_lengths
[x
]= strlen(keys
[x
]);
3019 oldalarm
= signal(SIGALRM
, fail
);
3022 rc
= memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
);
3023 test_true(rc
== MEMCACHED_SUCCESS
);
3026 signal(SIGALRM
, oldalarm
);
3028 size_t keys_returned
;
3029 test_true(fetch_all_results(memc
, &keys_returned
) == TEST_SUCCESS
);
3031 for (x
= 0; x
< key_count
; x
++)
3036 memcached_free(memc_clone
);
3038 return TEST_SUCCESS
;
3042 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3044 test_return_t test_rc
;
3045 test_rc
= pre_binary(memc
);
3047 if (test_rc
!= TEST_SUCCESS
)
3052 /* should work as of r580 */
3053 rc
= _user_supplied_bug21(memc
, 10);
3054 test_true(rc
== TEST_SUCCESS
);
3056 /* should fail as of r580 */
3057 rc
= _user_supplied_bug21(memc
, 1000);
3058 test_true(rc
== TEST_SUCCESS
);
3060 return TEST_SUCCESS
;
3063 static test_return_t
auto_eject_hosts(memcached_st
*trash
)
3066 memcached_server_instance_st instance
;
3068 memcached_return_t rc
;
3069 memcached_st
*memc
= memcached_create(NULL
);
3072 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3073 test_true(rc
== MEMCACHED_SUCCESS
);
3075 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3076 test_true(value
== 1);
3078 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3079 test_true(rc
== MEMCACHED_SUCCESS
);
3081 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3082 test_true(value
== MEMCACHED_HASH_MD5
);
3084 /* server should be removed when in delay */
3085 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
3086 test_true(rc
== MEMCACHED_SUCCESS
);
3088 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
3089 test_true(value
== 1);
3091 memcached_server_st
*server_pool
;
3092 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");
3093 memcached_server_push(memc
, server_pool
);
3095 /* verify that the server list was parsed okay. */
3096 test_true(memcached_server_count(memc
) == 8);
3097 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
3098 test_true(server_pool
[0].port
== 11211);
3099 test_true(server_pool
[0].weight
== 600);
3100 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
3101 test_true(server_pool
[2].port
== 11211);
3102 test_true(server_pool
[2].weight
== 200);
3103 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
3104 test_true(server_pool
[7].port
== 11211);
3105 test_true(server_pool
[7].weight
== 100);
3107 instance
= memcached_server_instance_by_position(memc
, 2);
3108 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) + 15;
3109 memc
->ketama
.next_distribution_rebuild
= time(NULL
) - 1;
3112 This would not work if there were only two hosts.
3114 for (size_t x
= 0; x
< 99; x
++)
3116 memcached_autoeject(memc
);
3117 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3118 test_true(server_idx
!= 2);
3121 /* and re-added when it's back. */
3122 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) - 1;
3123 memc
->ketama
.next_distribution_rebuild
= time(NULL
) - 1;
3124 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
,
3125 memc
->distribution
);
3126 for (size_t x
= 0; x
< 99; x
++)
3128 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3129 // We re-use instance from above.
3131 memcached_server_instance_by_position(memc
, server_idx
);
3132 const char *hostname
= memcached_server_name(instance
);
3133 test_true(strcmp(hostname
, ketama_test_cases
[x
].server
) == 0);
3136 memcached_server_list_free(server_pool
);
3137 memcached_free(memc
);
3139 return TEST_SUCCESS
;
3142 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
3146 memcached_return_t rc
;
3147 memcached_st
*memc
= memcached_create(NULL
);
3151 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3152 test_true(rc
== MEMCACHED_SUCCESS
);
3154 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3155 test_true(value
== 1);
3157 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3158 test_true(rc
== MEMCACHED_SUCCESS
);
3160 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3161 test_true(value
== MEMCACHED_HASH_MD5
);
3164 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3166 memcached_server_st
*server_pool
;
3167 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");
3168 memcached_server_push(memc
, server_pool
);
3170 // @todo this needs to be refactored to actually test something.
3173 if ((fp
= fopen("ketama_keys.txt", "w")))
3177 printf("cannot write to file ketama_keys.txt");
3178 return TEST_FAILURE
;
3181 for (int x
= 0; x
< 10000; x
++)
3184 snprintf(key
, sizeof(key
), "%d", x
);
3186 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3187 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3188 in_port_t port
= memc
->hosts
[server_idx
].port
;
3189 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3190 memcached_server_instance_st instance
=
3191 memcached_server_instance_by_position(memc
, host_index
);
3195 memcached_server_list_free(server_pool
);
3196 memcached_free(memc
);
3198 return TEST_SUCCESS
;
3202 static test_return_t
result_static(memcached_st
*memc
)
3204 memcached_result_st result
;
3205 memcached_result_st
*result_ptr
;
3207 result_ptr
= memcached_result_create(memc
, &result
);
3208 test_true(result
.options
.is_allocated
== false);
3209 test_true(memcached_is_initialized(&result
) == true);
3210 test_true(result_ptr
);
3211 test_true(result_ptr
== &result
);
3213 memcached_result_free(&result
);
3215 test_true(result
.options
.is_allocated
== false);
3216 test_true(memcached_is_initialized(&result
) == false);
3218 return TEST_SUCCESS
;
3221 static test_return_t
result_alloc(memcached_st
*memc
)
3223 memcached_result_st
*result_ptr
;
3225 result_ptr
= memcached_result_create(memc
, NULL
);
3226 test_true(result_ptr
);
3227 test_true(result_ptr
->options
.is_allocated
== true);
3228 test_true(memcached_is_initialized(result_ptr
) == true);
3229 memcached_result_free(result_ptr
);
3231 return TEST_SUCCESS
;
3234 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3237 pairs_free(global_pairs
);
3239 return TEST_SUCCESS
;
3242 static test_return_t
generate_pairs(memcached_st
*memc
)
3245 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3246 global_count
= GLOBAL_COUNT
;
3248 for (size_t x
= 0; x
< global_count
; x
++)
3250 global_keys
[x
]= global_pairs
[x
].key
;
3251 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3254 return TEST_SUCCESS
;
3257 static test_return_t
generate_large_pairs(memcached_st
*memc
)
3260 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3261 global_count
= GLOBAL2_COUNT
;
3263 for (size_t x
= 0; x
< global_count
; x
++)
3265 global_keys
[x
]= global_pairs
[x
].key
;
3266 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3269 return TEST_SUCCESS
;
3272 static test_return_t
generate_data(memcached_st
*memc
)
3274 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3276 test_true(check_execute
== global_count
);
3278 return TEST_SUCCESS
;
3281 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3283 memcached_stat_st
*stat_p
;
3284 memcached_return_t rc
;
3285 uint32_t host_index
= 0;
3286 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3288 test_true(check_execute
== global_count
);
3290 //TODO: hosts used size stats
3291 stat_p
= memcached_stat(memc
, NULL
, &rc
);
3294 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3296 /* This test was changes so that "make test" would work properlly */
3298 memcached_server_instance_st instance
=
3299 memcached_server_instance_by_position(memc
, host_index
);
3301 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3303 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3306 memcached_stat_free(NULL
, stat_p
);
3308 return TEST_SUCCESS
;
3310 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3315 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3316 generate_data(memc
);
3318 return TEST_SUCCESS
;
3321 static test_return_t
get_read_count(memcached_st
*memc
)
3323 memcached_return_t rc
;
3324 memcached_st
*memc_clone
;
3326 memc_clone
= memcached_clone(NULL
, memc
);
3327 test_true(memc_clone
);
3329 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3333 size_t return_value_length
;
3337 for (size_t x
= count
= 0; x
< global_count
; x
++)
3339 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3340 &return_value_length
, &flags
, &rc
);
3341 if (rc
== MEMCACHED_SUCCESS
)
3350 memcached_free(memc_clone
);
3352 return TEST_SUCCESS
;
3355 static test_return_t
get_read(memcached_st
*memc
)
3357 memcached_return_t rc
;
3361 size_t return_value_length
;
3364 for (size_t x
= 0; x
< global_count
; x
++)
3366 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3367 &return_value_length
, &flags
, &rc
);
3369 test_true(return_value);
3370 test_true(rc == MEMCACHED_SUCCESS);
3372 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3377 return TEST_SUCCESS
;
3380 static test_return_t
mget_read(memcached_st
*memc
)
3382 memcached_return_t rc
;
3384 if (! libmemcached_util_version_check(memc
, 1, 4, 4))
3385 return TEST_SKIPPED
;
3387 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3389 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
3391 // Go fetch the keys and test to see if all of them were returned
3393 size_t keys_returned
;
3394 test_true(fetch_all_results(memc
, &keys_returned
) == TEST_SUCCESS
);
3396 snprintf(buffer
, sizeof(buffer
), "%lu", (unsigned long)keys_returned
);
3397 test_true_got(global_count
== keys_returned
, buffer
);
3401 return TEST_SUCCESS
;
3404 static test_return_t
mget_read_result(memcached_st
*memc
)
3406 memcached_return_t rc
;
3408 if (! libmemcached_util_version_check(memc
, 1, 4, 4))
3409 return TEST_SKIPPED
;
3411 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3413 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
3415 /* Turn this into a help function */
3417 memcached_result_st results_obj
;
3418 memcached_result_st
*results
;
3420 results
= memcached_result_create(memc
, &results_obj
);
3422 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3425 test_true(rc
== MEMCACHED_SUCCESS
);
3428 memcached_result_free(&results_obj
);
3431 return TEST_SUCCESS
;
3434 static test_return_t
mget_read_function(memcached_st
*memc
)
3436 memcached_return_t rc
;
3438 memcached_execute_fn callbacks
[1];
3440 if (! libmemcached_util_version_check(memc
, 1, 4, 4))
3441 return TEST_SKIPPED
;
3443 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3445 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
3447 callbacks
[0]= &callback_counter
;
3449 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
3451 return TEST_SUCCESS
;
3454 static test_return_t
delete_generate(memcached_st
*memc
)
3456 for (size_t x
= 0; x
< global_count
; x
++)
3458 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3461 return TEST_SUCCESS
;
3464 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3469 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3471 for (size_t x
= 0; x
< global_count
; x
++)
3473 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3476 return TEST_SUCCESS
;
3479 static test_return_t
add_host_test1(memcached_st
*memc
)
3481 memcached_return_t rc
;
3482 char servername
[]= "0.example.com";
3483 memcached_server_st
*servers
;
3485 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3487 test_true(1 == memcached_server_list_count(servers
));
3489 for (size_t x
= 2; x
< 20; x
++)
3491 char buffer
[SMALL_STRING_LEN
];
3493 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3494 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3496 test_true(rc
== MEMCACHED_SUCCESS
);
3497 test_true(x
== memcached_server_list_count(servers
));
3500 rc
= memcached_server_push(memc
, servers
);
3501 test_true(rc
== MEMCACHED_SUCCESS
);
3502 rc
= memcached_server_push(memc
, servers
);
3503 test_true(rc
== MEMCACHED_SUCCESS
);
3505 memcached_server_list_free(servers
);
3507 return TEST_SUCCESS
;
3510 static test_return_t
pre_nonblock(memcached_st
*memc
)
3512 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3514 return TEST_SUCCESS
;
3517 static test_return_t
pre_cork(memcached_st
*memc
)
3519 memcached_return_t rc
;
3522 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
3525 return TEST_SKIPPED
;
3528 if (rc
== MEMCACHED_SUCCESS
)
3529 return TEST_SUCCESS
;
3531 return TEST_SKIPPED
;
3534 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3541 return TEST_SKIPPED
;
3544 if (rc
!= TEST_SUCCESS
)
3547 return pre_nonblock(memc
);
3550 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3552 memcached_return_t rc
= MEMCACHED_FAILURE
;
3553 memcached_st
*memc_clone
;
3555 memc_clone
= memcached_clone(NULL
, memc
);
3556 test_true(memc_clone
);
3557 // The memcached_version needs to be done on a clone, because the server
3558 // will not toggle protocol on an connection.
3559 memcached_version(memc_clone
);
3561 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3563 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3564 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3565 test_true(rc
== MEMCACHED_SUCCESS
);
3566 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3570 return TEST_SKIPPED
;
3573 memcached_free(memc_clone
);
3575 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3578 static test_return_t
pre_murmur(memcached_st
*memc
)
3580 #ifdef HAVE_MURMUR_HASH
3581 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3582 return TEST_SUCCESS
;
3585 return TEST_SKIPPED
;
3589 static test_return_t
pre_jenkins(memcached_st
*memc
)
3591 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3593 return TEST_SUCCESS
;
3597 static test_return_t
pre_md5(memcached_st
*memc
)
3599 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3601 return TEST_SUCCESS
;
3604 static test_return_t
pre_crc(memcached_st
*memc
)
3606 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3608 return TEST_SUCCESS
;
3611 static test_return_t
pre_hsieh(memcached_st
*memc
)
3613 #ifdef HAVE_HSIEH_HASH
3614 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3615 return TEST_SUCCESS
;
3618 return TEST_SKIPPED
;
3622 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3624 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3626 return TEST_SUCCESS
;
3629 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3631 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3633 return TEST_SUCCESS
;
3636 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3638 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3640 return TEST_SUCCESS
;
3643 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3645 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3647 return TEST_SUCCESS
;
3650 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3652 memcached_return_t rc
;
3655 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3656 test_true(rc
== MEMCACHED_SUCCESS
);
3658 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3659 test_true(value
== 1);
3661 return TEST_SUCCESS
;
3664 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3666 memcached_return_t rc
;
3669 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3670 test_true(rc
== MEMCACHED_SUCCESS
);
3672 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3673 test_true(value
== 1);
3675 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3676 test_true(rc
== MEMCACHED_SUCCESS
);
3678 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3679 test_true(value
== MEMCACHED_HASH_MD5
);
3681 return TEST_SUCCESS
;
3685 @note This should be testing to see if the server really supports the binary protocol.
3687 static test_return_t
pre_binary(memcached_st
*memc
)
3689 memcached_return_t rc
= MEMCACHED_FAILURE
;
3691 if (libmemcached_util_version_check(memc
, 1, 4, 4))
3693 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3694 test_true(rc
== MEMCACHED_SUCCESS
);
3695 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3698 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3701 static test_return_t
pre_sasl(memcached_st
*memc
)
3703 memcached_return_t rc
= MEMCACHED_FAILURE
;
3705 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
3706 const char *server
= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
3707 const char *user
= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
3708 const char *pass
= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
3710 if (server
!= NULL
&& user
!= NULL
&& pass
!= NULL
)
3712 memcached_server_st
*servers
= memcached_servers_parse(server
);
3713 test_true(servers
!= NULL
);
3714 memcached_servers_reset(memc
);
3715 test_true(memcached_server_push(memc
, servers
) == MEMCACHED_SUCCESS
);
3716 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3717 rc
= memcached_set_sasl_auth_data(memc
, user
, pass
);
3718 test_true(rc
== MEMCACHED_SUCCESS
);
3724 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3727 static test_return_t
pre_replication(memcached_st
*memc
)
3729 test_return_t test_rc
;
3730 test_rc
= pre_binary(memc
);
3732 if (test_rc
!= TEST_SUCCESS
)
3736 * Make sure that we store the item on all servers
3737 * (master + replicas == number of servers)
3739 memcached_return_t rc
;
3740 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3741 memcached_server_count(memc
) - 1);
3742 test_true(rc
== MEMCACHED_SUCCESS
);
3743 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memcached_server_count(memc
) - 1);
3745 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3749 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3753 rc
= pre_replication(memc
);
3754 if (rc
!= TEST_SUCCESS
)
3757 rc
= pre_nonblock(memc
);
3763 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3767 #ifdef HARD_MALLOC_TESTS
3768 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3776 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3780 #ifdef HARD_MALLOC_TESTS
3781 void *ret
= malloc(size
+ 8);
3784 ret
= (void*)((caddr_t
)ret
+ 8);
3787 void *ret
= malloc(size
);
3792 memset(ret
, 0xff, size
);
3799 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *context
)
3802 #ifdef HARD_MALLOC_TESTS
3803 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3804 void *nmem
= realloc(real_ptr
, size
+ 8);
3809 ret
= (void*)((caddr_t
)nmem
+ 8);
3815 return realloc(mem
, size
);
3820 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *context
)
3823 #ifdef HARD_MALLOC_TESTS
3824 void *mem
= my_malloc(ptr
, nelem
* size
);
3827 memset(mem
, 0, nelem
* size
);
3833 return calloc(nelem
, size
);
3838 static test_return_t
set_prefix(memcached_st
*memc
)
3840 memcached_return_t rc
;
3841 const char *key
= "mine";
3844 /* Make sure be default none exists */
3845 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3846 test_true(rc
== MEMCACHED_FAILURE
);
3848 /* Test a clean set */
3849 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3850 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_last_error_message(memc
));
3852 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3854 test_true(memcmp(value
, key
, 4) == 0);
3855 test_true(rc
== MEMCACHED_SUCCESS
);
3857 /* Test that we can turn it off */
3858 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3859 test_true(rc
== MEMCACHED_SUCCESS
);
3861 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3863 test_true(rc
== MEMCACHED_FAILURE
);
3865 /* Now setup for main test */
3866 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3867 test_true(rc
== MEMCACHED_SUCCESS
);
3869 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3871 test_true(rc
== MEMCACHED_SUCCESS
);
3872 test_true(memcmp(value
, key
, 4) == 0);
3874 /* Set to Zero, and then Set to something too large */
3877 memset(long_key
, 0, 255);
3879 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3880 test_true(rc
== MEMCACHED_SUCCESS
);
3882 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3884 test_true(rc
== MEMCACHED_FAILURE
);
3885 test_true(value
== NULL
);
3887 /* Test a long key for failure */
3888 /* TODO, extend test to determine based on setting, what result should be */
3889 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3890 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3891 //test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3892 test_true(rc
== MEMCACHED_SUCCESS
);
3894 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3895 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3896 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3897 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3899 /* Test for a bad prefix, but with a short key */
3900 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3901 test_true(rc
== MEMCACHED_SUCCESS
);
3903 strncpy(long_key
, "dog cat", sizeof(long_key
));
3904 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3905 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3908 return TEST_SUCCESS
;
3912 #ifdef MEMCACHED_ENABLE_DEPRECATED
3913 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3915 void *test_ptr
= NULL
;
3918 memcached_malloc_fn malloc_cb
=
3919 (memcached_malloc_fn
)my_malloc
;
3920 cb_ptr
= *(void **)&malloc_cb
;
3921 memcached_return_t rc
;
3923 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
3924 test_true(rc
== MEMCACHED_SUCCESS
);
3925 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3926 test_true(rc
== MEMCACHED_SUCCESS
);
3927 test_true(test_ptr
== cb_ptr
);
3931 memcached_realloc_fn realloc_cb
=
3932 (memcached_realloc_fn
)my_realloc
;
3933 cb_ptr
= *(void **)&realloc_cb
;
3934 memcached_return_t rc
;
3936 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
3937 test_true(rc
== MEMCACHED_SUCCESS
);
3938 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3939 test_true(rc
== MEMCACHED_SUCCESS
);
3940 test_true(test_ptr
== cb_ptr
);
3944 memcached_free_fn free_cb
=
3945 (memcached_free_fn
)my_free
;
3946 cb_ptr
= *(void **)&free_cb
;
3947 memcached_return_t rc
;
3949 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
3950 test_true(rc
== MEMCACHED_SUCCESS
);
3951 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3952 test_true(rc
== MEMCACHED_SUCCESS
);
3953 test_true(test_ptr
== cb_ptr
);
3956 return TEST_SUCCESS
;
3961 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3963 memcached_return_t rc
;
3964 rc
= memcached_set_memory_allocators(memc
, NULL
, my_free
,
3965 my_realloc
, my_calloc
, NULL
);
3966 test_true(rc
== MEMCACHED_FAILURE
);
3968 rc
= memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3969 my_realloc
, my_calloc
, NULL
);
3971 memcached_malloc_fn mem_malloc
;
3972 memcached_free_fn mem_free
;
3973 memcached_realloc_fn mem_realloc
;
3974 memcached_calloc_fn mem_calloc
;
3975 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3976 &mem_realloc
, &mem_calloc
);
3978 test_true(mem_malloc
== my_malloc
);
3979 test_true(mem_realloc
== my_realloc
);
3980 test_true(mem_calloc
== my_calloc
);
3981 test_true(mem_free
== my_free
);
3983 return TEST_SUCCESS
;
3986 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3989 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3990 memcached_hash_t hash
;
3991 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3992 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3995 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3996 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3998 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4000 if (hash
!= MEMCACHED_HASH_CRC
)
4001 return TEST_SKIPPED
;
4003 return TEST_SUCCESS
;
4006 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
4009 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4010 memcached_hash_t hash
;
4011 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4012 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
4015 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4016 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4018 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4020 if (hash
!= MEMCACHED_HASH_HSIEH
)
4021 return TEST_SKIPPED
;
4024 return TEST_SUCCESS
;
4027 static test_return_t
enable_cas(memcached_st
*memc
)
4029 unsigned int set
= 1;
4031 if (libmemcached_util_version_check(memc
, 1, 2, 4))
4033 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
4035 return TEST_SUCCESS
;
4038 return TEST_SKIPPED
;
4041 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
4043 memcached_version(memc
);
4045 memcached_server_instance_st instance
=
4046 memcached_server_instance_by_position(memc
, 0);
4048 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
4049 || instance
->minor_version
> 2)
4051 return TEST_SUCCESS
;
4054 return TEST_SKIPPED
;
4057 static test_return_t
pre_unix_socket(memcached_st
*memc
)
4059 memcached_return_t rc
;
4062 memcached_servers_reset(memc
);
4064 if (stat("/tmp/memcached.socket", &buf
))
4065 return TEST_SKIPPED
;
4067 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
4069 return ( rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_FAILURE
);
4072 static test_return_t
pre_nodelay(memcached_st
*memc
)
4074 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
4075 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
4077 return TEST_SUCCESS
;
4080 static test_return_t
pre_settimer(memcached_st
*memc
)
4082 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4083 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4085 return TEST_SUCCESS
;
4088 static test_return_t
poll_timeout(memcached_st
*memc
)
4094 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4096 timeout
= (size_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
4098 test_true(timeout
== 100);
4100 return TEST_SUCCESS
;
4103 static test_return_t
noreply_test(memcached_st
*memc
)
4105 memcached_return_t ret
;
4106 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
4107 test_true(ret
== MEMCACHED_SUCCESS
);
4108 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4109 test_true(ret
== MEMCACHED_SUCCESS
);
4110 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
4111 test_true(ret
== MEMCACHED_SUCCESS
);
4112 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
4113 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
4114 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
4116 for (int count
=0; count
< 5; ++count
)
4118 for (size_t x
= 0; x
< 100; ++x
)
4121 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4122 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4124 size_t len
= (size_t)check_length
;
4129 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4132 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4135 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4138 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4141 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4147 test_true(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
4151 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4152 ** API and is _ONLY_ done this way to verify that the library works the
4153 ** way it is supposed to do!!!!
4156 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4158 memcached_server_instance_st instance
=
4159 memcached_server_instance_by_position(memc
, x
);
4160 no_msg
+=(int)(instance
->cursor_active
);
4163 test_true(no_msg
== 0);
4164 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4167 ** Now validate that all items was set properly!
4169 for (size_t x
= 0; x
< 100; ++x
)
4173 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4175 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4177 size_t len
= (size_t)check_length
;
4180 char* value
=memcached_get(memc
, key
, strlen(key
),
4181 &length
, &flags
, &ret
);
4182 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4185 case 0: /* FALLTHROUGH */
4186 case 1: /* FALLTHROUGH */
4188 test_true(strncmp(value
, key
, len
) == 0);
4189 test_true(len
== length
);
4192 test_true(length
== len
* 2);
4195 test_true(length
== len
* 3);
4205 /* Try setting an illegal cas value (should not return an error to
4206 * the caller (because we don't expect a return message from the server)
4208 const char* keys
[]= {"0"};
4209 size_t lengths
[]= {1};
4212 memcached_result_st results_obj
;
4213 memcached_result_st
*results
;
4214 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4215 test_true(ret
== MEMCACHED_SUCCESS
);
4217 results
= memcached_result_create(memc
, &results_obj
);
4219 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4221 test_true(ret
== MEMCACHED_SUCCESS
);
4222 uint64_t cas
= memcached_result_cas(results
);
4223 memcached_result_free(&results_obj
);
4225 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4226 test_true(ret
== MEMCACHED_SUCCESS
);
4229 * The item will have a new cas value, so try to set it again with the old
4230 * value. This should fail!
4232 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4233 test_true(ret
== MEMCACHED_SUCCESS
);
4234 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4235 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4236 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4239 return TEST_SUCCESS
;
4242 static test_return_t
analyzer_test(memcached_st
*memc
)
4244 memcached_return_t rc
;
4245 memcached_stat_st
*memc_stat
;
4246 memcached_analysis_st
*report
;
4248 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4249 test_true(rc
== MEMCACHED_SUCCESS
);
4250 test_true(memc_stat
);
4252 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4253 test_true(rc
== MEMCACHED_SUCCESS
);
4257 memcached_stat_free(NULL
, memc_stat
);
4259 return TEST_SUCCESS
;
4262 /* Count the objects */
4263 static memcached_return_t
callback_dump_counter(const memcached_st
*ptr
,
4268 (void)ptr
; (void)key
; (void)key_length
;
4269 size_t *counter
= (size_t *)context
;
4271 *counter
= *counter
+ 1;
4273 return MEMCACHED_SUCCESS
;
4276 static test_return_t
dump_test(memcached_st
*memc
)
4278 memcached_return_t rc
;
4280 memcached_dump_fn callbacks
[1];
4281 test_return_t main_rc
;
4283 callbacks
[0]= &callback_dump_counter
;
4285 /* No support for Binary protocol yet */
4286 if (memc
->flags
.binary_protocol
)
4287 return TEST_SUCCESS
;
4289 main_rc
= set_test3(memc
);
4291 test_true (main_rc
== TEST_SUCCESS
);
4293 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
4294 test_true(rc
== MEMCACHED_SUCCESS
);
4296 /* We may have more then 32 if our previous flush has not completed */
4297 test_true(counter
>= 32);
4299 return TEST_SUCCESS
;
4302 #ifdef HAVE_LIBMEMCACHEDUTIL
4303 static void* connection_release(void *arg
)
4306 memcached_pool_st
* pool
;
4311 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
4315 #define POOL_SIZE 10
4316 static test_return_t
connection_pool_test(memcached_st
*memc
)
4318 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4319 test_true(pool
!= NULL
);
4320 memcached_st
*mmc
[POOL_SIZE
];
4321 memcached_return_t rc
;
4323 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4325 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4326 test_true(mmc
[x
] != NULL
);
4327 test_true(rc
== MEMCACHED_SUCCESS
);
4330 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4331 test_true(rc
== MEMCACHED_SUCCESS
);
4335 memcached_pool_st
* pool
;
4337 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
4338 pthread_create(&tid
, NULL
, connection_release
, &item
);
4339 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4340 test_true(rc
== MEMCACHED_SUCCESS
);
4341 pthread_join(tid
, NULL
);
4342 test_true(mmc
[9] == item
.mmc
);
4343 const char *key
= "key";
4344 size_t keylen
= strlen(key
);
4346 // verify that I can do ops with all connections
4347 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
4348 test_true(rc
== MEMCACHED_SUCCESS
);
4350 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4352 uint64_t number_value
;
4353 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
4354 test_true(rc
== MEMCACHED_SUCCESS
);
4355 test_true(number_value
== (x
+1));
4359 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4361 test_true(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
4365 /* verify that I can set behaviors on the pool when I don't have all
4366 * of the connections in the pool. It should however be enabled
4367 * when I push the item into the pool
4369 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4370 test_true(mmc
[0] != NULL
);
4372 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4373 test_true(rc
== MEMCACHED_SUCCESS
);
4375 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4376 test_true(mmc
[1] != NULL
);
4378 test_true(memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4379 test_true(memcached_pool_push(pool
, mmc
[1]) == MEMCACHED_SUCCESS
);
4380 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4382 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4383 test_true(memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4384 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4386 test_true(memcached_pool_destroy(pool
) == memc
);
4388 return TEST_SUCCESS
;
4391 static test_return_t
util_version_test(memcached_st
*memc
)
4395 if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4396 test_true(if_successful
== true);
4398 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4400 // We expect failure
4403 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4404 fprintf(stderr
, "\nDumping Server Information\n\n");
4405 memcached_server_fn callbacks
[1];
4407 callbacks
[0]= dump_server_information
;
4408 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4409 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4411 test_true(if_successful
== false);
4413 memcached_server_instance_st instance
=
4414 memcached_server_instance_by_position(memc
, 0);
4416 memcached_version(memc
);
4418 // We only use one binary when we test, so this should be just fine.
4419 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4420 test_true(if_successful
== true);
4422 if (instance
->micro_version
> 0)
4423 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4424 else if (instance
->minor_version
> 0)
4425 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4426 else if (instance
->major_version
> 0)
4427 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4429 test_true(if_successful
== true);
4431 if (instance
->micro_version
> 0)
4432 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4433 else if (instance
->minor_version
> 0)
4434 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4435 else if (instance
->major_version
> 0)
4436 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4438 test_true(if_successful
== false);
4440 return TEST_SUCCESS
;
4443 static test_return_t
ping_test(memcached_st
*memc
)
4445 memcached_return_t rc
;
4446 memcached_server_instance_st instance
=
4447 memcached_server_instance_by_position(memc
, 0);
4449 // Test both the version that returns a code, and the one that does not.
4450 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4451 memcached_server_port(instance
), NULL
));
4453 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4454 memcached_server_port(instance
), &rc
));
4456 test_true(rc
== MEMCACHED_SUCCESS
);
4458 return TEST_SUCCESS
;
4464 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4468 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4469 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4470 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4471 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4472 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4473 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4474 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4475 #ifdef HAVE_HSIEH_HASH
4476 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4478 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4479 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4480 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4482 return TEST_SUCCESS
;
4486 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4488 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4489 #ifdef HAVE_HSIEH_HASH
4490 expected_rc
= MEMCACHED_SUCCESS
;
4492 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4493 (uint64_t)MEMCACHED_HASH_HSIEH
);
4494 test_true(rc
== expected_rc
);
4496 return TEST_SUCCESS
;
4499 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4501 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4502 #ifdef HAVE_MURMUR_HASH
4503 expected_rc
= MEMCACHED_SUCCESS
;
4505 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4506 (uint64_t)MEMCACHED_HASH_MURMUR
);
4507 test_true(rc
== expected_rc
);
4509 return TEST_SUCCESS
;
4512 static test_return_t
one_at_a_time_run (memcached_st
*memc
)
4518 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4522 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
);
4523 test_true(one_at_a_time_values
[x
] == hash_val
);
4526 return TEST_SUCCESS
;
4529 static test_return_t
md5_run (memcached_st
*memc
)
4535 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4539 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4540 test_true(md5_values
[x
] == hash_val
);
4543 return TEST_SUCCESS
;
4546 static test_return_t
crc_run (memcached_st
*memc
)
4552 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4556 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4557 test_true(crc_values
[x
] == hash_val
);
4560 return TEST_SUCCESS
;
4563 static test_return_t
fnv1_64_run (memcached_st
*memc
)
4569 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4573 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4574 test_true(fnv1_64_values
[x
] == hash_val
);
4577 return TEST_SUCCESS
;
4580 static test_return_t
fnv1a_64_run (memcached_st
*memc
)
4586 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4590 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4591 test_true(fnv1a_64_values
[x
] == hash_val
);
4594 return TEST_SUCCESS
;
4597 static test_return_t
fnv1_32_run (memcached_st
*memc
)
4603 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4607 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4608 test_true(fnv1_32_values
[x
] == hash_val
);
4611 return TEST_SUCCESS
;
4614 static test_return_t
fnv1a_32_run (memcached_st
*memc
)
4620 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4624 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4625 test_true(fnv1a_32_values
[x
] == hash_val
);
4628 return TEST_SUCCESS
;
4631 static test_return_t
hsieh_run (memcached_st
*memc
)
4637 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4641 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4642 test_true(hsieh_values
[x
] == hash_val
);
4645 return TEST_SUCCESS
;
4648 static test_return_t
murmur_run (memcached_st
*memc
)
4650 #ifdef WORDS_BIGENDIAN
4651 (void)murmur_values
;
4652 return TEST_SKIPPED
;
4658 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4662 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
4663 test_true(murmur_values
[x
] == hash_val
);
4666 return TEST_SUCCESS
;
4670 static test_return_t
jenkins_run (memcached_st
*memc
)
4676 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4680 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4681 test_true(jenkins_values
[x
] == hash_val
);
4684 return TEST_SUCCESS
;
4687 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *context
)
4690 return libhashkit_md5(string
, string_length
);
4693 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *context
)
4696 return libhashkit_crc32(string
, string_length
);
4699 static test_return_t
memcached_get_hashkit_test (memcached_st
*memc
)
4703 const hashkit_st
*kit
;
4705 hashkit_return_t hash_rc
;
4707 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};
4708 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};
4710 kit
= memcached_get_hashkit(memc
);
4712 hashkit_clone(&new_kit
, kit
);
4713 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
);
4714 test_true(hash_rc
== HASHKIT_SUCCESS
);
4716 memcached_set_hashkit(memc
, &new_kit
);
4719 Verify Setting the hash.
4721 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4725 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4726 test_true(md5_values
[x
] == hash_val
);
4731 Now check memcached_st.
4733 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4737 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4738 test_true(md5_hosts
[x
] == hash_val
);
4741 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
);
4742 test_true(hash_rc
== HASHKIT_SUCCESS
);
4744 memcached_set_hashkit(memc
, &new_kit
);
4747 Verify Setting the hash.
4749 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4753 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4754 test_true(crc_values
[x
] == hash_val
);
4757 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4761 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4762 test_true(crc_hosts
[x
] == hash_val
);
4765 return TEST_SUCCESS
;
4769 Test case adapted from John Gorman <johngorman2@gmail.com>
4771 We are testing the error condition when we connect to a server via memcached_get()
4772 but find that the server is not available.
4774 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*memc
)
4777 memcached_st
*tl_memc_h
;
4778 memcached_server_st
*servers
;
4780 const char *key
= "MemcachedLives";
4783 memcached_return rc
;
4787 tl_memc_h
= memcached_create(NULL
);
4788 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4789 memcached_server_push(tl_memc_h
, servers
);
4790 memcached_server_list_free(servers
);
4792 // See if memcached is reachable.
4793 value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4796 test_true(len
== 0);
4797 test_false(rc
== MEMCACHED_SUCCESS
);
4799 memcached_free(tl_memc_h
);
4801 return TEST_SUCCESS
;
4805 We connect to a server which exists, but search for a key that does not exist.
4807 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4809 const char *key
= "MemcachedKeyNotEXIST";
4812 memcached_return rc
;
4815 // See if memcached is reachable.
4816 value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4819 test_true(len
== 0);
4820 test_true(rc
== MEMCACHED_NOTFOUND
);
4822 return TEST_SUCCESS
;
4826 Test case adapted from John Gorman <johngorman2@gmail.com>
4828 We are testing the error condition when we connect to a server via memcached_get_by_key()
4829 but find that the server is not available.
4831 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4834 memcached_st
*tl_memc_h
;
4835 memcached_server_st
*servers
;
4837 const char *key
= "MemcachedLives";
4840 memcached_return rc
;
4844 tl_memc_h
= memcached_create(NULL
);
4845 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4846 memcached_server_push(tl_memc_h
, servers
);
4847 memcached_server_list_free(servers
);
4849 // See if memcached is reachable.
4850 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4853 test_true(len
== 0);
4854 test_false(rc
== MEMCACHED_SUCCESS
);
4856 memcached_free(tl_memc_h
);
4858 return TEST_SUCCESS
;
4862 We connect to a server which exists, but search for a key that does not exist.
4864 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4866 const char *key
= "MemcachedKeyNotEXIST";
4869 memcached_return rc
;
4872 // See if memcached is reachable.
4873 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4876 test_true(len
== 0);
4877 test_true(rc
== MEMCACHED_NOTFOUND
);
4879 return TEST_SUCCESS
;
4883 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*trash
)
4885 memcached_return_t rc
;
4888 memcached_server_st
*server_pool
;
4893 memc
= memcached_create(NULL
);
4896 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
4897 test_true(rc
== MEMCACHED_SUCCESS
);
4899 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
4900 test_true(value
== 1);
4902 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
) == MEMCACHED_SUCCESS
);
4903 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
);
4906 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");
4907 memcached_server_push(memc
, server_pool
);
4909 /* verify that the server list was parsed okay. */
4910 test_true(memcached_server_count(memc
) == 8);
4911 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
4912 test_true(server_pool
[0].port
== 11211);
4913 test_true(server_pool
[0].weight
== 600);
4914 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
4915 test_true(server_pool
[2].port
== 11211);
4916 test_true(server_pool
[2].weight
== 200);
4917 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
4918 test_true(server_pool
[7].port
== 11211);
4919 test_true(server_pool
[7].weight
== 100);
4921 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
4922 * us test the boundary wraparound.
4924 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
4926 /* verify the standard ketama set. */
4927 for (x
= 0; x
< 99; x
++)
4929 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
4930 memcached_server_instance_st instance
=
4931 memcached_server_instance_by_position(memc
, server_idx
);
4932 const char *hostname
= memcached_server_name(instance
);
4934 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
4937 memcached_server_list_free(server_pool
);
4938 memcached_free(memc
);
4940 return TEST_SUCCESS
;
4943 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*trash
)
4945 memcached_return_t rc
;
4947 memcached_server_st
*server_pool
;
4952 memc
= memcached_create(NULL
);
4955 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
4956 test_true(rc
== MEMCACHED_SUCCESS
);
4958 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
4959 test_true(value
== 1);
4961 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
4962 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
);
4964 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");
4965 assert(server_pool
);
4966 memcached_server_push(memc
, server_pool
);
4968 /* verify that the server list was parsed okay. */
4969 test_true(memcached_server_count(memc
) == 8);
4970 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
4971 test_true(server_pool
[0].port
== 11211);
4972 test_true(server_pool
[0].weight
== 600);
4973 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
4974 test_true(server_pool
[2].port
== 11211);
4975 test_true(server_pool
[2].weight
== 200);
4976 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
4977 test_true(server_pool
[7].port
== 11211);
4978 test_true(server_pool
[7].weight
== 100);
4980 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
4981 * us test the boundary wraparound.
4983 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
4985 /* verify the standard ketama set. */
4986 for (uint32_t x
= 0; x
< 99; x
++)
4988 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
4990 memcached_server_instance_st instance
=
4991 memcached_server_instance_by_position(memc
, server_idx
);
4993 const char *hostname
= memcached_server_name(instance
);
4995 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
4998 memcached_server_list_free(server_pool
);
4999 memcached_free(memc
);
5001 return TEST_SUCCESS
;
5004 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5006 test_return_t test_rc
;
5007 test_rc
= pre_binary(memc
);
5009 if (test_rc
!= TEST_SUCCESS
)
5012 memcached_return_t ret
;
5013 const char *key
= "regression_bug_434484";
5014 size_t keylen
= strlen(key
);
5016 ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5017 test_true(ret
== MEMCACHED_NOTSTORED
);
5019 size_t size
= 2048 * 1024;
5020 void *data
= calloc(1, size
);
5021 test_true(data
!= NULL
);
5022 ret
= memcached_set(memc
, key
, keylen
, data
, size
, 0, 0);
5023 test_true(ret
== MEMCACHED_E2BIG
);
5026 return TEST_SUCCESS
;
5029 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5031 test_return_t test_rc
;
5032 test_rc
= pre_binary(memc
);
5034 if (test_rc
!= TEST_SUCCESS
)
5037 memcached_return_t rc
;
5039 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5042 * I only want to hit only _one_ server so I know the number of requests I'm
5043 * sending in the pipleine to the server. Let's try to do a multiget of
5044 * 1024 (that should satisfy most users don't you think?). Future versions
5045 * will include a mget_execute function call if you need a higher number.
5047 uint32_t number_of_hosts
= memcached_server_count(memc
);
5048 memc
->number_of_hosts
= 1;
5049 const size_t max_keys
= 1024;
5050 char **keys
= calloc(max_keys
, sizeof(char*));
5051 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5053 for (size_t x
= 0; x
< max_keys
; ++x
)
5057 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5059 test_true(keys
[x
] != NULL
);
5063 * Run two times.. the first time we should have 100% cache miss,
5064 * and the second time we should have 100% cache hits
5066 for (size_t y
= 0; y
< 2; y
++)
5068 rc
= memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
);
5069 test_true(rc
== MEMCACHED_SUCCESS
);
5070 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5074 /* The first iteration should give me a 100% cache miss. verify that*/
5075 char blob
[1024]= { 0 };
5077 test_true(counter
== 0);
5079 for (size_t x
= 0; x
< max_keys
; ++x
)
5081 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5082 blob
, sizeof(blob
), 0, 0);
5083 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5088 /* Verify that we received all of the key/value pairs */
5089 test_true(counter
== max_keys
);
5093 /* Release allocated resources */
5094 for (size_t x
= 0; x
< max_keys
; ++x
)
5101 memc
->number_of_hosts
= number_of_hosts
;
5103 return TEST_SUCCESS
;
5106 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5108 memcached_return_t rc
;
5109 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5110 test_true(rc
== MEMCACHED_SUCCESS
);
5112 return regression_bug_434843(memc
);
5115 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5117 memcached_return_t rc
;
5118 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5119 test_true(rc
== MEMCACHED_SUCCESS
);
5121 char *bytes
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5122 test_true(rc
== MEMCACHED_SUCCESS
);
5123 test_true(bytes
!= NULL
);
5124 char *bytes_read
= memcached_stat_get_value(memc
, memc_stat
,
5126 test_true(rc
== MEMCACHED_SUCCESS
);
5127 test_true(bytes_read
!= NULL
);
5129 char *bytes_written
= memcached_stat_get_value(memc
, memc_stat
,
5130 "bytes_written", &rc
);
5131 test_true(rc
== MEMCACHED_SUCCESS
);
5132 test_true(bytes_written
!= NULL
);
5134 test_true(strcmp(bytes
, bytes_read
) != 0);
5135 test_true(strcmp(bytes
, bytes_written
) != 0);
5137 /* Release allocated resources */
5140 free(bytes_written
);
5141 memcached_stat_free(NULL
, memc_stat
);
5143 return TEST_SUCCESS
;
5147 * The test case isn't obvious so I should probably document why
5148 * it works the way it does. Bug 442914 was caused by a bug
5149 * in the logic in memcached_purge (it did not handle the case
5150 * where the number of bytes sent was equal to the watermark).
5151 * In this test case, create messages so that we hit that case
5152 * and then disable noreply mode and issue a new command to
5153 * verify that it isn't stuck. If we change the format for the
5154 * delete command or the watermarks, we need to update this
5157 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5159 memcached_return_t rc
;
5160 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
5161 test_true(rc
== MEMCACHED_SUCCESS
);
5162 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5164 uint32_t number_of_hosts
= memcached_server_count(memc
);
5165 memc
->number_of_hosts
= 1;
5170 for (uint32_t x
= 0; x
< 250; ++x
)
5172 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5173 rc
= memcached_delete(memc
, k
, len
, 0);
5174 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5177 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5180 rc
= memcached_delete(memc
, k
, len
, 0);
5181 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5183 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0);
5184 test_true(rc
== MEMCACHED_SUCCESS
);
5185 rc
= memcached_delete(memc
, k
, len
, 0);
5186 test_true(rc
== MEMCACHED_NOTFOUND
);
5188 memc
->number_of_hosts
= number_of_hosts
;
5190 return TEST_SUCCESS
;
5193 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5195 memcached_server_instance_st instance_one
;
5196 memcached_server_instance_st instance_two
;
5198 if (memcached_server_count(memc
) < 3 || pre_replication(memc
) != TEST_SUCCESS
)
5199 return TEST_SKIPPED
;
5201 memcached_return_t rc
;
5203 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2);
5204 test_true(rc
== MEMCACHED_SUCCESS
);
5206 const size_t max_keys
= 100;
5207 char **keys
= calloc(max_keys
, sizeof(char*));
5208 size_t *key_length
= calloc(max_keys
, sizeof(size_t));
5210 for (size_t x
= 0; x
< max_keys
; ++x
)
5214 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5216 test_true(keys
[x
] != NULL
);
5217 rc
= memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0);
5218 test_true(rc
== MEMCACHED_SUCCESS
);
5222 ** We are using the quiet commands to store the replicas, so we need
5223 ** to ensure that all of them are processed before we can continue.
5224 ** In the test we go directly from storing the object to trying to
5225 ** receive the object from all of the different servers, so we
5226 ** could end up in a race condition (the memcached server hasn't yet
5227 ** processed the quiet command from the replication set when it process
5228 ** the request from the other client (created by the clone)). As a
5229 ** workaround for that we call memcached_quit to send the quit command
5230 ** to the server and wait for the response ;-) If you use the test code
5231 ** as an example for your own code, please note that you shouldn't need
5234 memcached_quit(memc
);
5236 /* Verify that all messages are stored, and we didn't stuff too much
5239 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5240 test_true(rc
== MEMCACHED_SUCCESS
);
5243 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5244 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5245 /* Verify that we received all of the key/value pairs */
5246 test_true(counter
== max_keys
);
5248 memcached_quit(memc
);
5250 * Don't do the following in your code. I am abusing the internal details
5251 * within the library, and this is not a supported interface.
5252 * This is to verify correct behavior in the library. Fake that two servers
5255 instance_one
= memcached_server_instance_by_position(memc
, 0);
5256 instance_two
= memcached_server_instance_by_position(memc
, 2);
5257 in_port_t port0
= instance_one
->port
;
5258 in_port_t port2
= instance_two
->port
;
5260 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5261 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5263 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5264 test_true(rc
== MEMCACHED_SUCCESS
);
5267 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5268 test_true(counter
== (unsigned int)max_keys
);
5270 /* restore the memc handle */
5271 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5272 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5274 memcached_quit(memc
);
5276 /* Remove half of the objects */
5277 for (size_t x
= 0; x
< max_keys
; ++x
)
5281 rc
= memcached_delete(memc
, keys
[x
], key_length
[x
], 0);
5282 test_true(rc
== MEMCACHED_SUCCESS
);
5286 memcached_quit(memc
);
5287 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5288 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5290 /* now retry the command, this time we should have cache misses */
5291 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5292 test_true(rc
== MEMCACHED_SUCCESS
);
5295 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5296 test_true(counter
== (unsigned int)(max_keys
>> 1));
5298 /* Release allocated resources */
5299 for (size_t x
= 0; x
< max_keys
; ++x
)
5306 /* restore the memc handle */
5307 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5308 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5310 return TEST_SUCCESS
;
5313 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5315 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5316 test_true(memc_clone
!= NULL
);
5317 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5319 memcached_server_instance_st instance
=
5320 memcached_server_instance_by_position(memc_clone
, 0);
5322 if (instance
->major_version
> 1 ||
5323 (instance
->major_version
== 1 &&
5324 instance
->minor_version
> 2))
5326 /* Binary protocol doesn't support deferred delete */
5327 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5328 test_true(bin_clone
!= NULL
);
5329 test_true(memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1) == MEMCACHED_SUCCESS
);
5330 test_true(memcached_delete(bin_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5331 memcached_free(bin_clone
);
5333 memcached_quit(memc_clone
);
5335 /* If we know the server version, deferred delete should fail
5336 * with invalid arguments */
5337 test_true(memcached_delete(memc_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5339 /* If we don't know the server version, we should get a protocol error */
5340 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5342 /* but there is a bug in some of the memcached servers (1.4) that treats
5343 * the counter as noreply so it doesn't send the proper error message
5345 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5347 /* And buffered mode should be disabled and we should get protocol error */
5348 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 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 /* Same goes for noreply... */
5353 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1) == MEMCACHED_SUCCESS
);
5354 rc
= memcached_delete(memc
, "foo", 3, 1);
5355 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5357 /* but a normal request should go through (and be buffered) */
5358 test_true((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_BUFFERED
);
5359 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
5361 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0) == MEMCACHED_SUCCESS
);
5362 /* unbuffered noreply should be success */
5363 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_SUCCESS
);
5364 /* unbuffered with reply should be not found... */
5365 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0) == MEMCACHED_SUCCESS
);
5366 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_NOTFOUND
);
5369 memcached_free(memc_clone
);
5370 return TEST_SUCCESS
;
5374 /* Test memcached_server_get_last_disconnect
5375 * For a working server set, shall be NULL
5376 * For a set of non existing server, shall not be NULL
5378 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5380 memcached_return_t rc
;
5381 memcached_server_instance_st disconnected_server
;
5383 /* With the working set of server */
5384 const char *key
= "marmotte";
5385 const char *value
= "milka";
5387 memcached_reset_last_disconnected_server(memc
);
5388 rc
= memcached_set(memc
, key
, strlen(key
),
5389 value
, strlen(value
),
5390 (time_t)0, (uint32_t)0);
5391 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5393 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5394 test_true(disconnected_server
== NULL
);
5396 /* With a non existing server */
5398 memcached_server_st
*servers
;
5400 const char *server_list
= "localhost:9";
5402 servers
= memcached_servers_parse(server_list
);
5404 mine
= memcached_create(NULL
);
5405 rc
= memcached_server_push(mine
, servers
);
5406 test_true(rc
== MEMCACHED_SUCCESS
);
5407 memcached_server_list_free(servers
);
5410 rc
= memcached_set(mine
, key
, strlen(key
),
5411 value
, strlen(value
),
5412 (time_t)0, (uint32_t)0);
5413 test_true(rc
!= MEMCACHED_SUCCESS
);
5415 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5416 if (disconnected_server
== NULL
)
5418 fprintf(stderr
, "RC %s\n", memcached_strerror(mine
, rc
));
5421 test_true(disconnected_server
!= NULL
);
5422 test_true(memcached_server_port(disconnected_server
)== 9);
5423 test_true(strncmp(memcached_server_name(disconnected_server
),"localhost",9) == 0);
5425 memcached_quit(mine
);
5426 memcached_free(mine
);
5428 return TEST_SUCCESS
;
5431 static test_return_t
test_verbosity(memcached_st
*memc
)
5433 memcached_verbosity(memc
, 3);
5435 return TEST_SUCCESS
;
5438 static test_return_t
test_server_failure(memcached_st
*memc
)
5440 memcached_st
*local_memc
;
5441 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
5443 local_memc
= memcached_create(NULL
);
5445 memcached_server_add(local_memc
, memcached_server_name(instance
), memcached_server_port(instance
));
5446 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 2);
5448 uint32_t server_count
= memcached_server_count(local_memc
);
5450 test_true(server_count
== 1);
5452 // Disable the server
5453 instance
= memcached_server_instance_by_position(local_memc
, 0);
5454 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 2;
5456 memcached_return_t rc
;
5457 rc
= memcached_set(local_memc
, "foo", strlen("foo"),
5459 (time_t)0, (uint32_t)0);
5460 test_true(rc
== MEMCACHED_SERVER_MARKED_DEAD
);
5462 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5463 rc
= memcached_set(local_memc
, "foo", strlen("foo"),
5465 (time_t)0, (uint32_t)0);
5466 test_true(rc
== MEMCACHED_SUCCESS
);
5469 memcached_free(local_memc
);
5471 return TEST_SUCCESS
;
5474 static test_return_t
test_cull_servers(memcached_st
*memc
)
5476 uint32_t count
= memcached_server_count(memc
);
5478 // Do not do this in your code, it is not supported.
5479 memc
->servers
[1].options
.is_dead
= true;
5480 memc
->state
.is_time_for_rebuild
= true;
5482 uint32_t new_count
= memcached_server_count(memc
);
5483 test_true(count
== new_count
);
5486 test_true(count
== new_count
+ 1 );
5489 return TEST_SUCCESS
;
5493 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5494 const char *key
, size_t key_length
,
5495 const char *value
, size_t value_length
,
5505 return MEMCACHED_SUCCESS
;
5508 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5510 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5511 test_true(rc
== MEMCACHED_SUCCESS
);
5513 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5514 test_true(rc
== MEMCACHED_SUCCESS
);
5516 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5517 test_true(rc
== MEMCACHED_SUCCESS
);
5519 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5520 test_true(rc
== MEMCACHED_SUCCESS
);
5522 return TEST_SUCCESS
;
5526 * This test ensures that the failure counter isn't incremented during
5527 * normal termination of the memcached instance.
5529 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5531 memcached_return_t rc
;
5532 memcached_server_instance_st instance
;
5534 /* Set value to force connection to the server */
5535 const char *key
= "marmotte";
5536 const char *value
= "milka";
5539 * Please note that I'm abusing the internal structures in libmemcached
5540 * in a non-portable way and you shouldn't be doing this. I'm only
5541 * doing this in order to verify that the library works the way it should
5543 uint32_t number_of_hosts
= memcached_server_count(memc
);
5544 memc
->number_of_hosts
= 1;
5546 /* Ensure that we are connected to the server by setting a value */
5547 rc
= memcached_set(memc
, key
, strlen(key
),
5548 value
, strlen(value
),
5549 (time_t)0, (uint32_t)0);
5550 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5553 instance
= memcached_server_instance_by_position(memc
, 0);
5554 /* The test is to see that the memcached_quit doesn't increase the
5555 * the server failure conter, so let's ensure that it is zero
5556 * before sending quit
5558 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5560 memcached_quit(memc
);
5562 /* Verify that it memcached_quit didn't increment the failure counter
5563 * Please note that this isn't bullet proof, because an error could
5566 test_true(instance
->server_failure_counter
== 0);
5568 /* restore the instance */
5569 memc
->number_of_hosts
= number_of_hosts
;
5571 return TEST_SUCCESS
;
5575 * This tests ensures expected disconnections (for some behavior changes
5576 * for instance) do not wrongly increase failure counter
5578 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5580 memcached_return rc
;
5582 memcached_st
*memc_clone
;
5583 memc_clone
= memcached_clone(NULL
, memc
);
5584 test_true(memc_clone
);
5586 /* Set value to force connection to the server */
5587 const char *key
= "marmotte";
5588 const char *value
= "milka";
5589 char *string
= NULL
;
5590 size_t string_length
;
5593 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5594 value
, strlen(value
),
5595 (time_t)0, (uint32_t)0);
5596 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5599 /* put failure limit to 1 */
5600 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5601 assert(rc
== MEMCACHED_SUCCESS
);
5603 /* Put a retry timeout to effectively activate failure_limit effect */
5604 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1);
5605 assert(rc
== MEMCACHED_SUCCESS
);
5607 /* change behavior that triggers memcached_quit()*/
5608 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5609 assert(rc
== MEMCACHED_SUCCESS
);
5612 /* Check if we still are connected */
5613 string
= memcached_get(memc_clone
, key
, strlen(key
),
5614 &string_length
, &flags
, &rc
);
5616 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
5619 memcached_free(memc_clone
);
5621 return TEST_SUCCESS
;
5628 * Test that ensures mget_execute does not end into recursive calls that finally fails
5630 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5632 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5633 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5634 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5635 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5636 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5639 return TEST_SKIPPED
; // My MAC can't handle this test
5643 * I only want to hit _one_ server so I know the number of requests I'm
5644 * sending in the pipeline.
5646 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5647 memc
->number_of_hosts
= 1;
5648 size_t max_keys
= 20480;
5651 char **keys
= calloc(max_keys
, sizeof(char*));
5652 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5654 /* First add all of the items.. */
5656 char blob
[1024]= { 0 };
5657 memcached_return rc
;
5658 for (size_t x
= 0; x
< max_keys
; ++x
)
5661 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5663 assert(keys
[x
] != NULL
);
5664 rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5666 if (rc
== MEMCACHED_SERVER_MARKED_DEAD
)
5668 break; // We are out of business
5671 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
); // MEMCACHED_TIMEOUT <-- only observed on OSX
5673 if (rc
== MEMCACHED_TIMEOUT
&& slept
== false)
5676 sleep(1);// We will try to sleep
5679 else if (rc
== MEMCACHED_TIMEOUT
&& slept
== true)
5681 // We failed to send everything.
5686 if (rc
!= MEMCACHED_SERVER_MARKED_DEAD
)
5689 /* Try to get all of them with a large multiget */
5691 memcached_execute_function callbacks
[1]= { [0]= &callback_counter
};
5692 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5693 (size_t)max_keys
, callbacks
, &counter
, 1);
5695 assert(rc
== MEMCACHED_SUCCESS
);
5696 char* the_value
= NULL
;
5697 char the_key
[MEMCACHED_MAX_KEY
];
5698 size_t the_key_length
;
5699 size_t the_value_length
;
5703 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5705 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5711 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5714 assert(rc
== MEMCACHED_END
);
5716 /* Verify that we got all of the items */
5717 assert(counter
== max_keys
);
5720 /* Release all allocated resources */
5721 for (size_t x
= 0; x
< max_keys
; ++x
)
5728 memc
->number_of_hosts
= number_of_hosts
;
5730 return TEST_SUCCESS
;
5733 static test_return_t
regression_bug_583031(memcached_st
*unused
)
5737 memcached_st
*memc
= memcached_create(NULL
);
5739 memcached_server_add(memc
, "10.2.3.4", 11211);
5741 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5742 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5743 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5744 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5745 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5746 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5748 memcached_return_t rc
;
5752 (void)memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5754 test_true_got(rc
== MEMCACHED_TIMEOUT
|| rc
== MEMCACHED_ERRNO
|| rc
== MEMCACHED_FAILURE
, memcached_strerror(memc
, rc
));
5756 memcached_free(memc
);
5758 return TEST_SUCCESS
;
5761 // Look for memory leak
5762 static test_return_t
regression_bug_728286(memcached_st
*unused
)
5765 memcached_server_st
*servers
= memcached_servers_parse("1.2.3.4:99");
5767 memcached_server_free(servers
);
5769 return TEST_SUCCESS
;
5772 static test_return_t
regression_bug_581030(memcached_st
*unused
)
5777 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5778 test_false(local_stat
);
5780 memcached_stat_free(NULL
, NULL
);
5783 return TEST_SUCCESS
;
5786 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5788 fprintf(stderr
, "Iteration #%u: ", it
);
5790 if(error
== MEMCACHED_ERRNO
)
5792 fprintf(stderr
, "system error %d from %s: %s\n",
5793 errno
, what
, strerror(errno
));
5797 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5798 memcached_strerror(mc
, error
));
5802 #define TEST_CONSTANT_CREATION 200
5804 static test_return_t
regression_bug_(memcached_st
*memc
)
5806 const char *remote_server
;
5809 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5811 return TEST_SKIPPED
;
5814 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5816 memcached_st
* mc
= memcached_create(NULL
);
5817 memcached_return rc
;
5819 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5820 if (rc
!= MEMCACHED_SUCCESS
)
5822 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5825 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5826 if (rc
!= MEMCACHED_SUCCESS
)
5828 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5831 rc
= memcached_server_add(mc
, remote_server
, 0);
5832 if (rc
!= MEMCACHED_SUCCESS
)
5834 memcached_die(mc
, rc
, "memcached_server_add", x
);
5837 const char *set_key
= "akey";
5838 const size_t set_key_len
= strlen(set_key
);
5839 const char *set_value
= "a value";
5840 const size_t set_value_len
= strlen(set_value
);
5842 if (rc
== MEMCACHED_SUCCESS
)
5846 size_t get_value_len
;
5848 uint32_t get_value_flags
;
5850 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5851 &get_value_flags
, &rc
);
5852 if (rc
!= MEMCACHED_SUCCESS
)
5854 memcached_die(mc
, rc
, "memcached_get", x
);
5860 (get_value_len
!= set_value_len
5861 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5863 fprintf(stderr
, "Values don't match?\n");
5864 rc
= MEMCACHED_FAILURE
;
5870 rc
= memcached_set(mc
,
5871 set_key
, set_key_len
,
5872 set_value
, set_value_len
,
5876 if (rc
!= MEMCACHED_SUCCESS
)
5878 memcached_die(mc
, rc
, "memcached_set", x
);
5885 if (rc
!= MEMCACHED_SUCCESS
)
5891 return TEST_SUCCESS
;
5895 * Test that the sasl authentication works. We cannot use the default
5896 * pool of servers, because that would require that all servers we want
5897 * to test supports SASL authentication, and that they use the default
5900 static test_return_t
sasl_auth_test(memcached_st
*memc
)
5902 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
5903 memcached_return_t rc
;
5905 rc
= memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
5906 test_true(rc
== MEMCACHED_SUCCESS
);
5907 test_true((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_SUCCESS
);
5908 test_true((rc
= memcached_destroy_sasl_auth_data(memc
)) == MEMCACHED_SUCCESS
);
5909 test_true((rc
= memcached_destroy_sasl_auth_data(memc
)) == MEMCACHED_FAILURE
);
5910 test_true((rc
= memcached_destroy_sasl_auth_data(NULL
)) == MEMCACHED_FAILURE
);
5911 memcached_quit(memc
);
5913 rc
= memcached_set_sasl_auth_data(memc
,
5914 getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
5915 getenv("LIBMEMCACHED_TEST_SASL_SERVER"));
5916 test_true(rc
== MEMCACHED_SUCCESS
);
5918 rc
= memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
5919 test_true(rc
== MEMCACHED_AUTH_FAILURE
);
5920 test_true(memcached_destroy_sasl_auth_data(memc
) == MEMCACHED_SUCCESS
);
5922 memcached_quit(memc
);
5923 return TEST_SUCCESS
;
5926 return TEST_FAILURE
;
5930 /* Clean the server before beginning testing */
5932 {"util_version", 1, (test_callback_fn
)util_version_test
},
5933 {"flush", 0, (test_callback_fn
)flush_test
},
5934 {"init", 0, (test_callback_fn
)init_test
},
5935 {"allocation", 0, (test_callback_fn
)allocation_test
},
5936 {"server_list_null_test", 0, (test_callback_fn
)server_list_null_test
},
5937 {"server_unsort", 0, (test_callback_fn
)server_unsort_test
},
5938 {"server_sort", 0, (test_callback_fn
)server_sort_test
},
5939 {"server_sort2", 0, (test_callback_fn
)server_sort2_test
},
5940 {"memcached_server_remove", 0, (test_callback_fn
)memcached_server_remove_test
},
5941 {"clone_test", 0, (test_callback_fn
)clone_test
},
5942 {"connection_test", 0, (test_callback_fn
)connection_test
},
5943 {"callback_test", 0, (test_callback_fn
)callback_test
},
5944 {"userdata_test", 0, (test_callback_fn
)userdata_test
},
5945 {"error", 0, (test_callback_fn
)error_test
},
5946 {"set", 0, (test_callback_fn
)set_test
},
5947 {"set2", 0, (test_callback_fn
)set_test2
},
5948 {"set3", 0, (test_callback_fn
)set_test3
},
5949 {"dump", 1, (test_callback_fn
)dump_test
},
5950 {"add", 1, (test_callback_fn
)add_test
},
5951 {"replace", 1, (test_callback_fn
)replace_test
},
5952 {"delete", 1, (test_callback_fn
)delete_test
},
5953 {"get", 1, (test_callback_fn
)get_test
},
5954 {"get2", 0, (test_callback_fn
)get_test2
},
5955 {"get3", 0, (test_callback_fn
)get_test3
},
5956 {"get4", 0, (test_callback_fn
)get_test4
},
5957 {"partial mget", 0, (test_callback_fn
)get_test5
},
5958 {"stats_servername", 0, (test_callback_fn
)stats_servername_test
},
5959 {"increment", 0, (test_callback_fn
)increment_test
},
5960 {"increment_with_initial", 1, (test_callback_fn
)increment_with_initial_test
},
5961 {"decrement", 0, (test_callback_fn
)decrement_test
},
5962 {"decrement_with_initial", 1, (test_callback_fn
)decrement_with_initial_test
},
5963 {"increment_by_key", 0, (test_callback_fn
)increment_by_key_test
},
5964 {"increment_with_initial_by_key", 1, (test_callback_fn
)increment_with_initial_by_key_test
},
5965 {"decrement_by_key", 0, (test_callback_fn
)decrement_by_key_test
},
5966 {"decrement_with_initial_by_key", 1, (test_callback_fn
)decrement_with_initial_by_key_test
},
5967 {"quit", 0, (test_callback_fn
)quit_test
},
5968 {"mget", 1, (test_callback_fn
)mget_test
},
5969 {"mget_result", 1, (test_callback_fn
)mget_result_test
},
5970 {"mget_result_alloc", 1, (test_callback_fn
)mget_result_alloc_test
},
5971 {"mget_result_function", 1, (test_callback_fn
)mget_result_function
},
5972 {"mget_execute", 1, (test_callback_fn
)mget_execute
},
5973 {"mget_end", 0, (test_callback_fn
)mget_end
},
5974 {"get_stats", 0, (test_callback_fn
)get_stats
},
5975 {"add_host_test", 0, (test_callback_fn
)add_host_test
},
5976 {"add_host_test_1", 0, (test_callback_fn
)add_host_test1
},
5977 {"get_stats_keys", 0, (test_callback_fn
)get_stats_keys
},
5978 {"version_string_test", 0, (test_callback_fn
)version_string_test
},
5979 {"bad_key", 1, (test_callback_fn
)bad_key_test
},
5980 {"memcached_server_cursor", 1, (test_callback_fn
)memcached_server_cursor_test
},
5981 {"read_through", 1, (test_callback_fn
)read_through
},
5982 {"delete_through", 1, (test_callback_fn
)delete_through
},
5983 {"noreply", 1, (test_callback_fn
)noreply_test
},
5984 {"analyzer", 1, (test_callback_fn
)analyzer_test
},
5985 #ifdef HAVE_LIBMEMCACHEDUTIL
5986 {"connectionpool", 1, (test_callback_fn
)connection_pool_test
},
5987 {"ping", 1, (test_callback_fn
)ping_test
},
5989 {"test_get_last_disconnect", 1, (test_callback_fn
)test_get_last_disconnect
},
5990 {"verbosity", 1, (test_callback_fn
)test_verbosity
},
5991 {"test_server_failure", 1, (test_callback_fn
)test_server_failure
},
5992 {"cull_servers", 1, (test_callback_fn
)test_cull_servers
},
5993 {"memcached_stat_execute", 1, (test_callback_fn
)memcached_stat_execute_test
},
5997 test_st behavior_tests
[] ={
5998 {"behavior_test", 0, (test_callback_fn
)behavior_test
},
5999 {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_CORK_test
},
6000 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
6001 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
6005 test_st basic_tests
[] ={
6006 {"init", 1, (test_callback_fn
)basic_init_test
},
6007 {"clone", 1, (test_callback_fn
)basic_clone_test
},
6008 {"reset", 1, (test_callback_fn
)basic_reset_stack_test
},
6009 {"reset heap", 1, (test_callback_fn
)basic_reset_heap_test
},
6010 {"reset stack clone", 1, (test_callback_fn
)basic_reset_stack_clone_test
},
6011 {"reset heap clone", 1, (test_callback_fn
)basic_reset_heap_clone_test
},
6015 test_st regression_binary_vs_block
[] ={
6016 {"block add", 1, (test_callback_fn
)block_add_regression
},
6017 {"binary add", 1, (test_callback_fn
)binary_add_regression
},
6021 test_st async_tests
[] ={
6022 {"add", 1, (test_callback_fn
)add_wrapper
},
6026 test_st string_tests
[] ={
6027 {"string static with null", 0, (test_callback_fn
)string_static_null
},
6028 {"string alloc with null", 0, (test_callback_fn
)string_alloc_null
},
6029 {"string alloc with 1K", 0, (test_callback_fn
)string_alloc_with_size
},
6030 {"string alloc with malloc failure", 0, (test_callback_fn
)string_alloc_with_size_toobig
},
6031 {"string append", 0, (test_callback_fn
)string_alloc_append
},
6032 {"string append failure (too big)", 0, (test_callback_fn
)string_alloc_append_toobig
},
6033 {"string_alloc_append_multiple", 0, (test_callback_fn
)string_alloc_append_multiple
},
6034 {0, 0, (test_callback_fn
)0}
6037 test_st result_tests
[] ={
6038 {"result static", 0, (test_callback_fn
)result_static
},
6039 {"result alloc", 0, (test_callback_fn
)result_alloc
},
6040 {0, 0, (test_callback_fn
)0}
6043 test_st version_1_2_3
[] ={
6044 {"append", 0, (test_callback_fn
)append_test
},
6045 {"prepend", 0, (test_callback_fn
)prepend_test
},
6046 {"cas", 0, (test_callback_fn
)cas_test
},
6047 {"cas2", 0, (test_callback_fn
)cas2_test
},
6048 {"append_binary", 0, (test_callback_fn
)append_binary_test
},
6049 {0, 0, (test_callback_fn
)0}
6052 test_st user_tests
[] ={
6053 {"user_supplied_bug1", 0, (test_callback_fn
)user_supplied_bug1
},
6054 {"user_supplied_bug2", 0, (test_callback_fn
)user_supplied_bug2
},
6055 {"user_supplied_bug3", 0, (test_callback_fn
)user_supplied_bug3
},
6056 {"user_supplied_bug4", 0, (test_callback_fn
)user_supplied_bug4
},
6057 {"user_supplied_bug5", 1, (test_callback_fn
)user_supplied_bug5
},
6058 {"user_supplied_bug6", 1, (test_callback_fn
)user_supplied_bug6
},
6059 {"user_supplied_bug7", 1, (test_callback_fn
)user_supplied_bug7
},
6060 {"user_supplied_bug8", 1, (test_callback_fn
)user_supplied_bug8
},
6061 {"user_supplied_bug9", 1, (test_callback_fn
)user_supplied_bug9
},
6062 {"user_supplied_bug10", 1, (test_callback_fn
)user_supplied_bug10
},
6063 {"user_supplied_bug11", 1, (test_callback_fn
)user_supplied_bug11
},
6064 {"user_supplied_bug12", 1, (test_callback_fn
)user_supplied_bug12
},
6065 {"user_supplied_bug13", 1, (test_callback_fn
)user_supplied_bug13
},
6066 {"user_supplied_bug14", 1, (test_callback_fn
)user_supplied_bug14
},
6067 {"user_supplied_bug15", 1, (test_callback_fn
)user_supplied_bug15
},
6068 {"user_supplied_bug16", 1, (test_callback_fn
)user_supplied_bug16
},
6069 #if !defined(__sun) && !defined(__OpenBSD__)
6071 ** It seems to be something weird with the character sets..
6072 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6073 ** guess I need to find out how this is supposed to work.. Perhaps I need
6074 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6075 ** so just disable the code for now...).
6077 {"user_supplied_bug17", 1, (test_callback_fn
)user_supplied_bug17
},
6079 {"user_supplied_bug18", 1, (test_callback_fn
)user_supplied_bug18
},
6080 {"user_supplied_bug19", 1, (test_callback_fn
)user_supplied_bug19
},
6081 {"user_supplied_bug20", 1, (test_callback_fn
)user_supplied_bug20
},
6082 {"user_supplied_bug21", 1, (test_callback_fn
)user_supplied_bug21
},
6083 {"wrong_failure_counter_test", 1, (test_callback_fn
)wrong_failure_counter_test
},
6084 {"wrong_failure_counter_two_test", 1, (test_callback_fn
)wrong_failure_counter_two_test
},
6085 {0, 0, (test_callback_fn
)0}
6088 test_st replication_tests
[]= {
6089 {"set", 1, (test_callback_fn
)replication_set_test
},
6090 {"get", 0, (test_callback_fn
)replication_get_test
},
6091 {"mget", 0, (test_callback_fn
)replication_mget_test
},
6092 {"delete", 0, (test_callback_fn
)replication_delete_test
},
6093 {"rand_mget", 0, (test_callback_fn
)replication_randomize_mget_test
},
6094 {0, 0, (test_callback_fn
)0}
6098 * The following test suite is used to verify that we don't introduce
6099 * regression bugs. If you want more information about the bug / test,
6100 * you should look in the bug report at
6101 * http://bugs.launchpad.net/libmemcached
6103 test_st regression_tests
[]= {
6104 {"lp:434484", 1, (test_callback_fn
)regression_bug_434484
},
6105 {"lp:434843", 1, (test_callback_fn
)regression_bug_434843
},
6106 {"lp:434843-buffered", 1, (test_callback_fn
)regression_bug_434843_buffered
},
6107 {"lp:421108", 1, (test_callback_fn
)regression_bug_421108
},
6108 {"lp:442914", 1, (test_callback_fn
)regression_bug_442914
},
6109 {"lp:447342", 1, (test_callback_fn
)regression_bug_447342
},
6110 {"lp:463297", 1, (test_callback_fn
)regression_bug_463297
},
6111 {"lp:490486", 1, (test_callback_fn
)regression_bug_490486
},
6112 {"lp:583031", 1, (test_callback_fn
)regression_bug_583031
},
6113 {"lp:?", 1, (test_callback_fn
)regression_bug_
},
6114 {"lp:728286", 1, (test_callback_fn
)regression_bug_728286
},
6115 {"lp:581030", 1, (test_callback_fn
)regression_bug_581030
},
6116 {0, 0, (test_callback_fn
)0}
6119 test_st sasl_auth_tests
[]= {
6120 {"sasl_auth", 1, (test_callback_fn
)sasl_auth_test
},
6121 {0, 0, (test_callback_fn
)0}
6124 test_st ketama_compatibility
[]= {
6125 {"libmemcached", 1, (test_callback_fn
)ketama_compatibility_libmemcached
},
6126 {"spymemcached", 1, (test_callback_fn
)ketama_compatibility_spymemcached
},
6127 {0, 0, (test_callback_fn
)0}
6130 test_st generate_tests
[] ={
6131 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6132 {"generate_data", 1, (test_callback_fn
)generate_data
},
6133 {"get_read", 0, (test_callback_fn
)get_read
},
6134 {"delete_generate", 0, (test_callback_fn
)delete_generate
},
6135 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
6136 {"delete_buffer", 0, (test_callback_fn
)delete_buffer_generate
},
6137 {"generate_data", 1, (test_callback_fn
)generate_data
},
6138 {"mget_read", 0, (test_callback_fn
)mget_read
},
6139 {"mget_read_result", 0, (test_callback_fn
)mget_read_result
},
6140 {"mget_read_function", 0, (test_callback_fn
)mget_read_function
},
6141 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6142 {"generate_large_pairs", 1, (test_callback_fn
)generate_large_pairs
},
6143 {"generate_data", 1, (test_callback_fn
)generate_data
},
6144 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
6145 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6146 {0, 0, (test_callback_fn
)0}
6149 test_st consistent_tests
[] ={
6150 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6151 {"generate_data", 1, (test_callback_fn
)generate_data
},
6152 {"get_read", 0, (test_callback_fn
)get_read_count
},
6153 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6154 {0, 0, (test_callback_fn
)0}
6157 test_st consistent_weighted_tests
[] ={
6158 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6159 {"generate_data", 1, (test_callback_fn
)generate_data_with_stats
},
6160 {"get_read", 0, (test_callback_fn
)get_read_count
},
6161 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6162 {0, 0, (test_callback_fn
)0}
6165 test_st hsieh_availability
[] ={
6166 {"hsieh_avaibility_test", 0, (test_callback_fn
)hsieh_avaibility_test
},
6167 {0, 0, (test_callback_fn
)0}
6170 test_st murmur_availability
[] ={
6171 {"murmur_avaibility_test", 0, (test_callback_fn
)murmur_avaibility_test
},
6172 {0, 0, (test_callback_fn
)0}
6176 test_st hash_sanity
[] ={
6177 {"hash sanity", 0, (test_callback_fn
)hash_sanity_test
},
6178 {0, 0, (test_callback_fn
)0}
6182 test_st ketama_auto_eject_hosts
[] ={
6183 {"auto_eject_hosts", 1, (test_callback_fn
)auto_eject_hosts
},
6184 {"output_ketama_weighted_keys", 1, (test_callback_fn
)output_ketama_weighted_keys
},
6185 {0, 0, (test_callback_fn
)0}
6188 test_st hash_tests
[] ={
6189 {"one_at_a_time_run", 0, (test_callback_fn
)one_at_a_time_run
},
6190 {"md5", 0, (test_callback_fn
)md5_run
},
6191 {"crc", 0, (test_callback_fn
)crc_run
},
6192 {"fnv1_64", 0, (test_callback_fn
)fnv1_64_run
},
6193 {"fnv1a_64", 0, (test_callback_fn
)fnv1a_64_run
},
6194 {"fnv1_32", 0, (test_callback_fn
)fnv1_32_run
},
6195 {"fnv1a_32", 0, (test_callback_fn
)fnv1a_32_run
},
6196 {"hsieh", 0, (test_callback_fn
)hsieh_run
},
6197 {"murmur", 0, (test_callback_fn
)murmur_run
},
6198 {"jenkis", 0, (test_callback_fn
)jenkins_run
},
6199 {"memcached_get_hashkit", 0, (test_callback_fn
)memcached_get_hashkit_test
},
6200 {0, 0, (test_callback_fn
)0}
6203 test_st error_conditions
[] ={
6204 {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn
)memcached_get_MEMCACHED_ERRNO
},
6205 {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
)memcached_get_MEMCACHED_NOTFOUND
},
6206 {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn
)memcached_get_by_key_MEMCACHED_ERRNO
},
6207 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6208 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6209 {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn
)memcached_increment_MEMCACHED_NO_SERVERS
},
6210 {0, 0, (test_callback_fn
)0}
6214 test_st parser_tests
[] ={
6215 {"behavior", 0, (test_callback_fn
)behavior_parser_test
},
6216 {"boolean_options", 0, (test_callback_fn
)parser_boolean_options_test
},
6217 {"configure_file", 0, (test_callback_fn
)memcached_create_with_options_with_filename
},
6218 {"distribtions", 0, (test_callback_fn
)parser_distribution_test
},
6219 {"hash", 0, (test_callback_fn
)parser_hash_test
},
6220 {"libmemcached_check_configuration", 0, (test_callback_fn
)libmemcached_check_configuration_test
},
6221 {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn
)libmemcached_check_configuration_with_filename_test
},
6222 {"memcached_parse_configure_file", 0, (test_callback_fn
)memcached_parse_configure_file_test
},
6223 {"number_options", 0, (test_callback_fn
)parser_number_options_test
},
6224 {"randomly generated options", 0, (test_callback_fn
)random_statement_build_test
},
6225 {"prefix_key", 0, (test_callback_fn
)parser_key_prefix_test
},
6226 {"server", 0, (test_callback_fn
)server_test
},
6227 {"bad server strings", 0, (test_callback_fn
)servers_bad_test
},
6228 {"server with weights", 0, (test_callback_fn
)server_with_weight_test
},
6229 {0, 0, (test_callback_fn
)0}
6232 test_st virtual_bucket_tests
[] ={
6233 {"basic", 0, (test_callback_fn
)virtual_back_map
},
6234 {0, 0, (test_callback_fn
)0}
6237 collection_st collection
[] ={
6239 {"hash_sanity", 0, 0, hash_sanity
},
6241 {"basic", 0, 0, basic_tests
},
6242 {"hsieh_availability", 0, 0, hsieh_availability
},
6243 {"murmur_availability", 0, 0, murmur_availability
},
6244 {"block", 0, 0, tests
},
6245 {"binary", (test_callback_fn
)pre_binary
, 0, tests
},
6246 {"nonblock", (test_callback_fn
)pre_nonblock
, 0, tests
},
6247 {"nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6248 {"settimer", (test_callback_fn
)pre_settimer
, 0, tests
},
6249 {"md5", (test_callback_fn
)pre_md5
, 0, tests
},
6250 {"crc", (test_callback_fn
)pre_crc
, 0, tests
},
6251 {"hsieh", (test_callback_fn
)pre_hsieh
, 0, tests
},
6252 {"jenkins", (test_callback_fn
)pre_jenkins
, 0, tests
},
6253 {"fnv1_64", (test_callback_fn
)pre_hash_fnv1_64
, 0, tests
},
6254 {"fnv1a_64", (test_callback_fn
)pre_hash_fnv1a_64
, 0, tests
},
6255 {"fnv1_32", (test_callback_fn
)pre_hash_fnv1_32
, 0, tests
},
6256 {"fnv1a_32", (test_callback_fn
)pre_hash_fnv1a_32
, 0, tests
},
6257 {"ketama", (test_callback_fn
)pre_behavior_ketama
, 0, tests
},
6258 {"ketama_auto_eject_hosts", (test_callback_fn
)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6259 {"unix_socket", (test_callback_fn
)pre_unix_socket
, 0, tests
},
6260 {"unix_socket_nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6261 {"poll_timeout", (test_callback_fn
)poll_timeout
, 0, tests
},
6262 {"gets", (test_callback_fn
)enable_cas
, 0, tests
},
6263 {"consistent_crc", (test_callback_fn
)enable_consistent_crc
, 0, tests
},
6264 {"consistent_hsieh", (test_callback_fn
)enable_consistent_hsieh
, 0, tests
},
6265 #ifdef MEMCACHED_ENABLE_DEPRECATED
6266 {"deprecated_memory_allocators", (test_callback_fn
)deprecated_set_memory_alloc
, 0, tests
},
6268 {"memory_allocators", (test_callback_fn
)set_memory_alloc
, 0, tests
},
6269 {"prefix", (test_callback_fn
)set_prefix
, 0, tests
},
6270 {"sasl_auth", (test_callback_fn
)pre_sasl
, 0, sasl_auth_tests
},
6271 {"sasl", (test_callback_fn
)pre_sasl
, 0, tests
},
6272 {"version_1_2_3", (test_callback_fn
)check_for_1_2_3
, 0, version_1_2_3
},
6273 {"string", 0, 0, string_tests
},
6274 {"result", 0, 0, result_tests
},
6275 {"async", (test_callback_fn
)pre_nonblock
, 0, async_tests
},
6276 {"async_binary", (test_callback_fn
)pre_nonblock_binary
, 0, async_tests
},
6277 {"user", 0, 0, user_tests
},
6278 {"generate", 0, 0, generate_tests
},
6279 {"generate_hsieh", (test_callback_fn
)pre_hsieh
, 0, generate_tests
},
6280 {"generate_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, generate_tests
},
6281 {"generate_hsieh_consistent", (test_callback_fn
)enable_consistent_hsieh
, 0, generate_tests
},
6282 {"generate_md5", (test_callback_fn
)pre_md5
, 0, generate_tests
},
6283 {"generate_murmur", (test_callback_fn
)pre_murmur
, 0, generate_tests
},
6284 {"generate_jenkins", (test_callback_fn
)pre_jenkins
, 0, generate_tests
},
6285 {"generate_nonblock", (test_callback_fn
)pre_nonblock
, 0, generate_tests
},
6287 {"generate_corked", (test_callback_fn
)pre_cork
, 0, generate_tests
},
6288 {"generate_corked_and_nonblock", (test_callback_fn
)pre_cork_and_nonblock
, 0, generate_tests
},
6289 {"consistent_not", 0, 0, consistent_tests
},
6290 {"consistent_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, consistent_tests
},
6291 {"consistent_ketama_weighted", (test_callback_fn
)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6292 {"ketama_compat", 0, 0, ketama_compatibility
},
6293 {"test_hashes", 0, 0, hash_tests
},
6294 {"replication", (test_callback_fn
)pre_replication
, 0, replication_tests
},
6295 {"replication_noblock", (test_callback_fn
)pre_replication_noblock
, 0, replication_tests
},
6296 {"regression", 0, 0, regression_tests
},
6297 {"behaviors", 0, 0, behavior_tests
},
6298 {"regression_binary_vs_block", (test_callback_fn
)key_setup
, (test_callback_fn
)key_teardown
, regression_binary_vs_block
},
6299 {"error_conditions", 0, 0, error_conditions
},
6300 {"parser", 0, 0, parser_tests
},
6301 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6305 #include "libmemcached_world.h"
6307 void get_world(world_st
*world
)
6309 world
->collections
= collection
;
6311 world
->create
= (test_callback_create_fn
)world_create
;
6312 world
->destroy
= (test_callback_fn
)world_destroy
;
6314 world
->test
.startup
= (test_callback_fn
)world_test_startup
;
6315 world
->test
.flush
= (test_callback_fn
)world_flush
;
6316 world
->test
.pre_run
= (test_callback_fn
)world_pre_run
;
6317 world
->test
.post_run
= (test_callback_fn
)world_post_run
;
6318 world
->test
.on_error
= (test_callback_error_fn
)world_on_error
;
6320 world
->collection
.startup
= (test_callback_fn
)world_container_startup
;
6321 world
->collection
.shutdown
= (test_callback_fn
)world_container_shutdown
;
6323 world
->runner
= &defualt_libmemcached_runner
;