1 /* libMemcached Functions Test
2 * Copyright (C) 2006-2009 Brian Aker
5 * Use and distribution licensed under the BSD license. See
6 * the COPYING file in the parent directory for full text.
10 Sample test application.
21 #include <sys/types.h>
27 #include "libmemcached/common.h"
29 #include <libtest/server.h>
31 #include "clients/generator.h"
32 #include "clients/execute.h"
34 #define SMALL_STRING_LEN 1024
36 #include <libtest/test.h>
37 #include "tests/parser.h"
38 #include "tests/string.h"
39 #include "tests/replication.h"
40 #include "tests/basic.h"
41 #include "tests/error_conditions.h"
42 #include "tests/print.h"
43 #include "tests/virtual_buckets.h"
46 #ifdef HAVE_LIBMEMCACHEDUTIL
48 #include "libmemcached/memcached_util.h"
51 #include "hash_results.h"
53 #define GLOBAL_COUNT 10000
54 #define GLOBAL2_COUNT 100
55 #define SERVERS_TO_CREATE 5
56 static uint32_t global_count
;
58 static pairs_st
*global_pairs
;
59 static const char *global_keys
[GLOBAL_COUNT
];
60 static size_t global_keys_length
[GLOBAL_COUNT
];
63 static test_return_t
pre_binary(memcached_st
*memc
);
66 static test_return_t
init_test(memcached_st
*not_used
)
71 (void)memcached_create(&memc
);
72 memcached_free(&memc
);
77 static test_return_t
server_list_null_test(memcached_st
*ptr
)
79 memcached_server_st
*server_list
;
80 memcached_return_t rc
;
83 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, NULL
);
84 test_true(server_list
== NULL
);
86 server_list
= memcached_server_list_append_with_weight(NULL
, "localhost", 0, 0, NULL
);
87 test_true(server_list
== NULL
);
89 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, &rc
);
90 test_true(server_list
== NULL
);
95 #define TEST_PORT_COUNT 7
96 in_port_t test_ports
[TEST_PORT_COUNT
];
98 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
99 const memcached_server_st
*server
,
103 size_t bigger
= *((size_t *)(context
));
105 assert(bigger
<= memcached_server_port(server
));
106 *((size_t *)(context
))= memcached_server_port(server
);
108 return MEMCACHED_SUCCESS
;
111 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
112 const memcached_server_st
*instance
,
116 FILE *stream
= (FILE *)context
;
119 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
120 memcached_server_name(instance
),
121 memcached_server_port(instance
),
122 instance
->major_version
,
123 instance
->minor_version
,
124 instance
->micro_version
);
126 return MEMCACHED_SUCCESS
;
129 static test_return_t
server_sort_test(memcached_st
*ptr
)
131 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
133 memcached_return_t rc
;
134 memcached_server_fn callbacks
[1];
135 memcached_st
*local_memc
;
138 local_memc
= memcached_create(NULL
);
139 test_true(local_memc
);
140 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
142 for (size_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
144 test_ports
[x
]= (in_port_t
)random() % 64000;
145 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
146 test_true(memcached_server_count(local_memc
) == x
+ 1);
148 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
150 test_true(rc
== MEMCACHED_SUCCESS
);
153 callbacks
[0]= server_display_function
;
154 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
157 memcached_free(local_memc
);
162 static test_return_t
server_sort2_test(memcached_st
*ptr
)
164 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
165 memcached_return_t rc
;
166 memcached_server_fn callbacks
[1];
167 memcached_st
*local_memc
;
168 memcached_server_instance_st instance
;
171 local_memc
= memcached_create(NULL
);
172 test_true(local_memc
);
173 rc
= memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
174 test_true(rc
== MEMCACHED_SUCCESS
);
176 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
177 test_true(rc
== MEMCACHED_SUCCESS
);
178 instance
= memcached_server_instance_by_position(local_memc
, 0);
179 test_true(memcached_server_port(instance
) == 43043);
181 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
182 test_true(rc
== MEMCACHED_SUCCESS
);
184 instance
= memcached_server_instance_by_position(local_memc
, 0);
185 test_true(memcached_server_port(instance
) == 43042);
187 instance
= memcached_server_instance_by_position(local_memc
, 1);
188 test_true(memcached_server_port(instance
) == 43043);
190 callbacks
[0]= server_display_function
;
191 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
194 memcached_free(local_memc
);
199 static test_return_t
memcached_server_remove_test(memcached_st
*ptr
)
201 memcached_return_t rc
;
202 memcached_st local_memc
;
204 memcached_server_st
*servers
;
205 memcached_server_fn callbacks
[1];
207 const char *server_string
= "localhost:4444, localhost:4445, localhost:4446, localhost:4447, localhost, memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
210 memc
= memcached_create(&local_memc
);
212 servers
= memcached_servers_parse(server_string
);
215 rc
= memcached_server_push(memc
, servers
);
216 memcached_server_list_free(servers
);
218 callbacks
[0]= server_print_callback
;
219 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
221 memcached_free(memc
);
226 static memcached_return_t
server_display_unsort_function(const memcached_st
*ptr
,
227 const memcached_server_st
*server
,
231 uint32_t x
= *((uint32_t *)(context
));
234 assert(test_ports
[x
] == server
->port
);
235 *((uint32_t *)(context
))= ++x
;
237 return MEMCACHED_SUCCESS
;
240 static test_return_t
server_unsort_test(memcached_st
*ptr
)
242 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
243 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
244 memcached_return_t rc
;
245 memcached_server_fn callbacks
[1];
246 memcached_st
*local_memc
;
249 local_memc
= memcached_create(NULL
);
250 test_true(local_memc
);
252 for (size_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
254 test_ports
[x
]= (in_port_t
)(random() % 64000);
255 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
256 test_true(memcached_server_count(local_memc
) == x
+1);
258 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
260 test_true(rc
== MEMCACHED_SUCCESS
);
263 callbacks
[0]= server_display_unsort_function
;
264 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
266 /* Now we sort old data! */
267 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
268 callbacks
[0]= server_display_function
;
269 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
272 memcached_free(local_memc
);
277 static test_return_t
allocation_test(memcached_st
*not_used
)
281 memc
= memcached_create(NULL
);
283 memcached_free(memc
);
288 static test_return_t
clone_test(memcached_st
*memc
)
292 memcached_st
*memc_clone
;
293 memc_clone
= memcached_clone(NULL
, NULL
);
294 test_true(memc_clone
);
295 memcached_free(memc_clone
);
298 /* Can we init from null? */
300 memcached_st
*memc_clone
;
301 memc_clone
= memcached_clone(NULL
, memc
);
302 test_true(memc_clone
);
305 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
306 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
307 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
308 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
311 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
312 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
313 test_true(memc_clone
->distribution
== memc
->distribution
);
314 { // Test all of the flags
315 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
316 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
317 test_true(memc_clone
->flags
.reuse_memory
== memc
->flags
.reuse_memory
);
318 test_true(memc_clone
->flags
.use_cache_lookups
== memc
->flags
.use_cache_lookups
);
319 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
320 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
321 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
322 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
323 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
324 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
325 test_true(memc_clone
->flags
.hash_with_prefix_key
== memc
->flags
.hash_with_prefix_key
);
326 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
327 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
328 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
329 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
331 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
332 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
333 test_true(hashkit_compare(&memc_clone
->distribution_hashkit
, &memc
->distribution_hashkit
));
334 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
335 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
336 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
337 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
338 test_true(memc_clone
->on_clone
== memc
->on_clone
);
339 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
340 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
341 test_true(memc_clone
->recv_size
== memc
->recv_size
);
342 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
343 test_true(memc_clone
->send_size
== memc
->send_size
);
344 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
345 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
346 test_true(memc_clone
->user_data
== memc
->user_data
);
348 memcached_free(memc_clone
);
351 /* Can we init from struct? */
353 memcached_st declared_clone
;
354 memcached_st
*memc_clone
;
355 memset(&declared_clone
, 0 , sizeof(memcached_st
));
356 memc_clone
= memcached_clone(&declared_clone
, NULL
);
357 test_true(memc_clone
);
358 memcached_free(memc_clone
);
361 /* Can we init from struct? */
363 memcached_st declared_clone
;
364 memcached_st
*memc_clone
;
365 memset(&declared_clone
, 0 , sizeof(memcached_st
));
366 memc_clone
= memcached_clone(&declared_clone
, memc
);
367 test_true(memc_clone
);
368 memcached_free(memc_clone
);
374 static test_return_t
userdata_test(memcached_st
*memc
)
377 test_true(memcached_set_user_data(memc
, foo
) == NULL
);
378 test_true(memcached_get_user_data(memc
) == foo
);
379 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
384 static test_return_t
connection_test(memcached_st
*memc
)
386 memcached_return_t rc
;
388 rc
= memcached_server_add_with_weight(memc
, "localhost", 0, 0);
389 test_true(rc
== MEMCACHED_SUCCESS
);
394 static test_return_t
error_test(memcached_st
*memc
)
396 memcached_return_t rc
;
397 uint32_t values
[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U,
398 982370485U, 1263635348U, 4242906218U, 3829656100U,
399 1891735253U, 334139633U, 2257084983U, 3088286104U,
400 13199785U, 2542027183U, 1097051614U, 199566778U,
401 2748246961U, 2465192557U, 1664094137U, 2405439045U,
402 1842224848U, 692413798U, 3479807801U, 919913813U,
403 4269430871U, 610793021U, 527273862U, 1437122909U,
404 2300930706U, 2943759320U, 674306647U, 2400528935U,
405 54481931U, 4186304426U, 1741088401U, 2979625118U,
406 4159057246U, 3425930182U, 2593724503U, 1868899624U,
407 1769812374U, 2302537950U, 1110330676U, 3365377466U,
408 1336171666U, 3365377466U };
410 // You have updated the memcache_error messages but not updated docs/tests.
411 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
414 const char *msg
= memcached_strerror(memc
, rc
);
415 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
416 MEMCACHED_HASH_JENKINS
);
417 if (values
[rc
] != hash_val
)
419 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the error_test\n");
420 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, rc
), hash_val
);
422 test_true(values
[rc
] == hash_val
);
424 test_true(MEMCACHED_MAXIMUM_RETURN
== 45);
429 static test_return_t
set_test(memcached_st
*memc
)
431 memcached_return_t rc
;
432 const char *key
= "foo";
433 const char *value
= "when we sanitize";
435 rc
= memcached_set(memc
, key
, strlen(key
),
436 value
, strlen(value
),
437 (time_t)0, (uint32_t)0);
438 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
443 static test_return_t
append_test(memcached_st
*memc
)
445 memcached_return_t rc
;
446 const char *key
= "fig";
447 const char *in_value
= "we";
448 char *out_value
= NULL
;
452 rc
= memcached_flush(memc
, 0);
453 test_true(rc
== MEMCACHED_SUCCESS
);
455 rc
= memcached_set(memc
, key
, strlen(key
),
456 in_value
, strlen(in_value
),
457 (time_t)0, (uint32_t)0);
458 test_true(rc
== MEMCACHED_SUCCESS
);
460 rc
= memcached_append(memc
, key
, strlen(key
),
461 " the", strlen(" the"),
462 (time_t)0, (uint32_t)0);
463 test_true(rc
== MEMCACHED_SUCCESS
);
465 rc
= memcached_append(memc
, key
, strlen(key
),
466 " people", strlen(" people"),
467 (time_t)0, (uint32_t)0);
468 test_true(rc
== MEMCACHED_SUCCESS
);
470 out_value
= memcached_get(memc
, key
, strlen(key
),
471 &value_length
, &flags
, &rc
);
472 test_true(!memcmp(out_value
, "we the people", strlen("we the people")));
473 test_true(strlen("we the people") == value_length
);
474 test_true(rc
== MEMCACHED_SUCCESS
);
480 static test_return_t
append_binary_test(memcached_st
*memc
)
482 memcached_return_t rc
;
483 const char *key
= "numbers";
484 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
490 rc
= memcached_flush(memc
, 0);
491 test_true(rc
== MEMCACHED_SUCCESS
);
493 rc
= memcached_set(memc
,
496 (time_t)0, (uint32_t)0);
497 test_true(rc
== MEMCACHED_SUCCESS
);
499 for (x
= 0; store_list
[x
] ; x
++)
501 rc
= memcached_append(memc
,
503 (char *)&store_list
[x
], sizeof(uint32_t),
504 (time_t)0, (uint32_t)0);
505 test_true(rc
== MEMCACHED_SUCCESS
);
508 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
509 &value_length
, &flags
, &rc
);
510 test_true((value_length
== (sizeof(uint32_t) * x
)));
511 test_true(rc
== MEMCACHED_SUCCESS
);
513 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
515 test_true(*ptr
== store_list
[x
- counter
]);
523 static test_return_t
cas2_test(memcached_st
*memc
)
525 memcached_return_t rc
;
526 const char *keys
[]= {"fudge", "son", "food"};
527 size_t key_length
[]= {5, 3, 4};
528 const char *value
= "we the people";
529 size_t value_length
= strlen("we the people");
531 memcached_result_st results_obj
;
532 memcached_result_st
*results
;
535 rc
= memcached_flush(memc
, 0);
536 test_true(rc
== MEMCACHED_SUCCESS
);
538 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
540 for (x
= 0; x
< 3; x
++)
542 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
543 keys
[x
], key_length
[x
],
544 (time_t)50, (uint32_t)9);
545 test_true(rc
== MEMCACHED_SUCCESS
);
548 rc
= memcached_mget(memc
, keys
, key_length
, 3);
550 results
= memcached_result_create(memc
, &results_obj
);
552 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
554 test_true(results
->item_cas
);
555 test_true(rc
== MEMCACHED_SUCCESS
);
556 test_true(memcached_result_cas(results
));
558 test_true(!memcmp(value
, "we the people", strlen("we the people")));
559 test_true(strlen("we the people") == value_length
);
560 test_true(rc
== MEMCACHED_SUCCESS
);
562 memcached_result_free(&results_obj
);
567 static test_return_t
cas_test(memcached_st
*memc
)
569 memcached_return_t rc
;
570 const char *key
= "fun";
571 size_t key_length
= strlen(key
);
572 const char *value
= "we the people";
573 const char* keys
[2] = { key
, NULL
};
574 size_t keylengths
[2] = { strlen(key
), 0 };
575 size_t value_length
= strlen(value
);
576 const char *value2
= "change the value";
577 size_t value2_length
= strlen(value2
);
579 memcached_result_st results_obj
;
580 memcached_result_st
*results
;
583 rc
= memcached_flush(memc
, 0);
584 test_true(rc
== MEMCACHED_SUCCESS
);
586 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
588 rc
= memcached_set(memc
, key
, strlen(key
),
589 value
, strlen(value
),
590 (time_t)0, (uint32_t)0);
591 test_true(rc
== MEMCACHED_SUCCESS
);
593 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
595 results
= memcached_result_create(memc
, &results_obj
);
597 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
599 test_true(rc
== MEMCACHED_SUCCESS
);
600 test_true(memcached_result_cas(results
));
601 test_true(!memcmp(value
, memcached_result_value(results
), value_length
));
602 test_true(strlen(memcached_result_value(results
)) == value_length
);
603 test_true(rc
== MEMCACHED_SUCCESS
);
604 uint64_t cas
= memcached_result_cas(results
);
607 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
608 test_true(rc
== MEMCACHED_END
);
609 test_true(results
== NULL
);
612 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
613 test_true(rc
== MEMCACHED_SUCCESS
);
616 * The item will have a new cas value, so try to set it again with the old
617 * value. This should fail!
619 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
620 test_true(rc
== MEMCACHED_DATA_EXISTS
);
622 memcached_result_free(&results_obj
);
627 static test_return_t
prepend_test(memcached_st
*memc
)
629 memcached_return_t rc
;
630 const char *key
= "fig";
631 const char *value
= "people";
632 char *out_value
= NULL
;
636 rc
= memcached_flush(memc
, 0);
637 test_true(rc
== MEMCACHED_SUCCESS
);
639 rc
= memcached_set(memc
, key
, strlen(key
),
640 value
, strlen(value
),
641 (time_t)0, (uint32_t)0);
642 test_true(rc
== MEMCACHED_SUCCESS
);
644 rc
= memcached_prepend(memc
, key
, strlen(key
),
645 "the ", strlen("the "),
646 (time_t)0, (uint32_t)0);
647 test_true(rc
== MEMCACHED_SUCCESS
);
649 rc
= memcached_prepend(memc
, key
, strlen(key
),
650 "we ", strlen("we "),
651 (time_t)0, (uint32_t)0);
652 test_true(rc
== MEMCACHED_SUCCESS
);
654 out_value
= memcached_get(memc
, key
, strlen(key
),
655 &value_length
, &flags
, &rc
);
656 test_true(!memcmp(out_value
, "we the people", strlen("we the people")));
657 test_true(strlen("we the people") == value_length
);
658 test_true(rc
== MEMCACHED_SUCCESS
);
665 Set the value, then quit to make sure it is flushed.
666 Come back in and test that add fails.
668 static test_return_t
add_test(memcached_st
*memc
)
670 memcached_return_t rc
;
671 const char *key
= "foo";
672 const char *value
= "when we sanitize";
673 unsigned long long setting_value
;
675 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
677 rc
= memcached_set(memc
, key
, strlen(key
),
678 value
, strlen(value
),
679 (time_t)0, (uint32_t)0);
680 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
681 memcached_quit(memc
);
682 rc
= memcached_add(memc
, key
, strlen(key
),
683 value
, strlen(value
),
684 (time_t)0, (uint32_t)0);
686 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
689 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
693 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
700 ** There was a problem of leaking filedescriptors in the initial release
701 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
702 ** systems it seems that the kernel is slow on reclaiming the resources
703 ** because the connects starts to time out (the test doesn't do much
704 ** anyway, so just loop 10 iterations)
706 static test_return_t
add_wrapper(memcached_st
*memc
)
708 unsigned int max
= 10000;
716 for (uint32_t x
= 0; x
< max
; x
++)
722 static test_return_t
replace_test(memcached_st
*memc
)
724 memcached_return_t rc
;
725 const char *key
= "foo";
726 const char *value
= "when we sanitize";
727 const char *original
= "first we insert some data";
729 rc
= memcached_set(memc
, key
, strlen(key
),
730 original
, strlen(original
),
731 (time_t)0, (uint32_t)0);
732 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
734 rc
= memcached_replace(memc
, key
, strlen(key
),
735 value
, strlen(value
),
736 (time_t)0, (uint32_t)0);
737 test_true(rc
== MEMCACHED_SUCCESS
);
742 static test_return_t
delete_test(memcached_st
*memc
)
744 memcached_return_t rc
;
745 const char *key
= "foo";
746 const char *value
= "when we sanitize";
748 rc
= memcached_set(memc
, key
, strlen(key
),
749 value
, strlen(value
),
750 (time_t)0, (uint32_t)0);
751 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
753 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
754 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
759 static test_return_t
flush_test(memcached_st
*memc
)
761 memcached_return_t rc
;
763 rc
= memcached_flush(memc
, 0);
764 test_true(rc
== MEMCACHED_SUCCESS
);
769 static memcached_return_t
server_function(const memcached_st
*ptr
,
770 const memcached_server_st
*server
,
773 (void)ptr
; (void)server
; (void)context
;
776 return MEMCACHED_SUCCESS
;
779 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
782 strncpy(context
, "foo bad", sizeof(context
));
783 memcached_server_fn callbacks
[1];
785 callbacks
[0]= server_function
;
786 memcached_server_cursor(memc
, callbacks
, context
, 1);
790 static test_return_t
bad_key_test(memcached_st
*memc
)
792 memcached_return_t rc
;
793 const char *key
= "foo bad";
795 size_t string_length
;
797 memcached_st
*memc_clone
;
799 size_t max_keylen
= 0xffff;
801 // Just skip if we are in binary mode.
802 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
805 memc_clone
= memcached_clone(NULL
, memc
);
806 test_true(memc_clone
);
808 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
809 test_true(rc
== MEMCACHED_SUCCESS
);
811 /* All keys are valid in the binary protocol (except for length) */
812 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 0)
814 string
= memcached_get(memc_clone
, key
, strlen(key
),
815 &string_length
, &flags
, &rc
);
816 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
817 test_true(string_length
== 0);
821 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
822 test_true(rc
== MEMCACHED_SUCCESS
);
823 string
= memcached_get(memc_clone
, key
, strlen(key
),
824 &string_length
, &flags
, &rc
);
825 test_true(rc
== MEMCACHED_NOTFOUND
);
826 test_true(string_length
== 0);
829 /* Test multi key for bad keys */
830 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
831 size_t key_lengths
[] = { 7, 7, 7 };
833 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
834 test_true(rc
== MEMCACHED_SUCCESS
);
836 rc
= memcached_mget(memc_clone
, keys
, key_lengths
, 3);
837 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
839 rc
= memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1);
840 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
844 /* The following test should be moved to the end of this function when the
845 memcached server is updated to allow max size length of the keys in the
848 rc
= memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
849 test_true(rc
== MEMCACHED_SUCCESS
);
851 char *longkey
= (char *)malloc(max_keylen
+ 1);
854 memset(longkey
, 'a', max_keylen
+ 1);
855 string
= memcached_get(memc_clone
, longkey
, max_keylen
,
856 &string_length
, &flags
, &rc
);
857 test_true(rc
== MEMCACHED_NOTFOUND
);
858 test_true(string_length
== 0);
861 string
= memcached_get(memc_clone
, longkey
, max_keylen
+ 1,
862 &string_length
, &flags
, &rc
);
863 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
864 test_true(string_length
== 0);
871 /* Make sure zero length keys are marked as bad */
873 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
874 test_true(rc
== MEMCACHED_SUCCESS
);
875 string
= memcached_get(memc_clone
, key
, 0,
876 &string_length
, &flags
, &rc
);
877 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
878 test_true(string_length
== 0);
881 memcached_free(memc_clone
);
886 #define READ_THROUGH_VALUE "set for me"
887 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
890 memcached_result_st
*result
)
892 (void)memc
;(void)key
;(void)key_length
;
893 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
896 static test_return_t
read_through(memcached_st
*memc
)
898 memcached_return_t rc
;
899 const char *key
= "foo";
901 size_t string_length
;
903 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
905 string
= memcached_get(memc
, key
, strlen(key
),
906 &string_length
, &flags
, &rc
);
908 test_true(rc
== MEMCACHED_NOTFOUND
);
909 test_false(string_length
);
912 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
,
914 test_true(rc
== MEMCACHED_SUCCESS
);
916 string
= memcached_get(memc
, key
, strlen(key
),
917 &string_length
, &flags
, &rc
);
919 test_true(rc
== MEMCACHED_SUCCESS
);
920 test_true(string_length
== strlen(READ_THROUGH_VALUE
));
921 test_strcmp(READ_THROUGH_VALUE
, string
);
924 string
= memcached_get(memc
, key
, strlen(key
),
925 &string_length
, &flags
, &rc
);
927 test_true(rc
== MEMCACHED_SUCCESS
);
928 test_true(string_length
== strlen(READ_THROUGH_VALUE
));
929 test_true(!strcmp(READ_THROUGH_VALUE
, string
));
935 static memcached_return_t
delete_trigger(memcached_st
*ptr
,
939 (void)ptr
;(void)key_length
;
942 return MEMCACHED_SUCCESS
;
945 static test_return_t
delete_through(memcached_st
*memc
)
947 memcached_trigger_delete_key_fn callback
;
948 memcached_return_t rc
;
950 callback
= (memcached_trigger_delete_key_fn
)delete_trigger
;
952 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
953 test_true(rc
== MEMCACHED_SUCCESS
);
958 static test_return_t
get_test(memcached_st
*memc
)
960 memcached_return_t rc
;
961 const char *key
= "foo";
963 size_t string_length
;
966 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
967 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
969 string
= memcached_get(memc
, key
, strlen(key
),
970 &string_length
, &flags
, &rc
);
972 test_true(rc
== MEMCACHED_NOTFOUND
);
973 test_false(string_length
);
979 static test_return_t
get_test2(memcached_st
*memc
)
981 memcached_return_t rc
;
982 const char *key
= "foo";
983 const char *value
= "when we sanitize";
985 size_t string_length
;
988 rc
= memcached_set(memc
, key
, strlen(key
),
989 value
, strlen(value
),
990 (time_t)0, (uint32_t)0);
991 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
993 string
= memcached_get(memc
, key
, strlen(key
),
994 &string_length
, &flags
, &rc
);
997 test_true(rc
== MEMCACHED_SUCCESS
);
998 test_true(string_length
== strlen(value
));
999 test_true(!memcmp(string
, value
, string_length
));
1003 return TEST_SUCCESS
;
1006 static test_return_t
set_test2(memcached_st
*memc
)
1008 memcached_return_t rc
;
1009 const char *key
= "foo";
1010 const char *value
= "train in the brain";
1011 size_t value_length
= strlen(value
);
1014 for (x
= 0; x
< 10; x
++)
1016 rc
= memcached_set(memc
, key
, strlen(key
),
1017 value
, value_length
,
1018 (time_t)0, (uint32_t)0);
1019 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1022 return TEST_SUCCESS
;
1025 static test_return_t
set_test3(memcached_st
*memc
)
1027 memcached_return_t rc
;
1029 size_t value_length
= 8191;
1032 value
= (char*)malloc(value_length
);
1035 for (x
= 0; x
< value_length
; x
++)
1036 value
[x
] = (char) (x
% 127);
1038 /* The dump test relies on there being at least 32 items in memcached */
1039 for (x
= 0; x
< 32; x
++)
1043 snprintf(key
, sizeof(key
), "foo%u", x
);
1045 rc
= memcached_set(memc
, key
, strlen(key
),
1046 value
, value_length
,
1047 (time_t)0, (uint32_t)0);
1048 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1053 return TEST_SUCCESS
;
1056 static test_return_t
get_test3(memcached_st
*memc
)
1058 memcached_return_t rc
;
1059 const char *key
= "foo";
1061 size_t value_length
= 8191;
1063 size_t string_length
;
1067 value
= (char*)malloc(value_length
);
1070 for (x
= 0; x
< value_length
; x
++)
1071 value
[x
] = (char) (x
% 127);
1073 rc
= memcached_set(memc
, key
, strlen(key
),
1074 value
, value_length
,
1075 (time_t)0, (uint32_t)0);
1076 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1078 string
= memcached_get(memc
, key
, strlen(key
),
1079 &string_length
, &flags
, &rc
);
1081 test_true(rc
== MEMCACHED_SUCCESS
);
1083 test_true(string_length
== value_length
);
1084 test_true(!memcmp(string
, value
, string_length
));
1089 return TEST_SUCCESS
;
1092 static test_return_t
get_test4(memcached_st
*memc
)
1094 memcached_return_t rc
;
1095 const char *key
= "foo";
1097 size_t value_length
= 8191;
1099 size_t string_length
;
1103 value
= (char*)malloc(value_length
);
1106 for (x
= 0; x
< value_length
; x
++)
1107 value
[x
] = (char) (x
% 127);
1109 rc
= memcached_set(memc
, key
, strlen(key
),
1110 value
, value_length
,
1111 (time_t)0, (uint32_t)0);
1112 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1114 for (x
= 0; x
< 10; x
++)
1116 string
= memcached_get(memc
, key
, strlen(key
),
1117 &string_length
, &flags
, &rc
);
1119 test_true(rc
== MEMCACHED_SUCCESS
);
1121 test_true(string_length
== value_length
);
1122 test_true(!memcmp(string
, value
, string_length
));
1128 return TEST_SUCCESS
;
1132 * This test verifies that memcached_read_one_response doesn't try to
1133 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1134 * responses before you execute a storage command.
1136 static test_return_t
get_test5(memcached_st
*memc
)
1139 ** Request the same key twice, to ensure that we hash to the same server
1140 ** (so that we have multiple response values queued up) ;-)
1142 const char *keys
[]= { "key", "key" };
1143 size_t lengths
[]= { 3, 3 };
1147 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1148 keys
[0], lengths
[0], 0, 0);
1149 test_true(rc
== MEMCACHED_SUCCESS
);
1150 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1152 memcached_result_st results_obj
;
1153 memcached_result_st
*results
;
1154 results
=memcached_result_create(memc
, &results_obj
);
1156 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
1158 memcached_result_free(&results_obj
);
1160 /* Don't read out the second result, but issue a set instead.. */
1161 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
1162 test_true(rc
== MEMCACHED_SUCCESS
);
1164 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1165 &rlen
, &flags
, &rc
);
1166 test_true(val
== NULL
);
1167 test_true(rc
== MEMCACHED_NOTFOUND
);
1168 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1169 test_true(val
!= NULL
);
1170 test_true(rc
== MEMCACHED_SUCCESS
);
1173 return TEST_SUCCESS
;
1176 static test_return_t
mget_end(memcached_st
*memc
)
1178 const char *keys
[]= { "foo", "foo2" };
1179 size_t lengths
[]= { 3, 4 };
1180 const char *values
[]= { "fjord", "41" };
1182 memcached_return_t rc
;
1185 for (int i
= 0; i
< 2; i
++)
1187 rc
= memcached_set(memc
, keys
[i
], lengths
[i
], values
[i
], strlen(values
[i
]),
1188 (time_t)0, (uint32_t)0);
1189 test_true(rc
== MEMCACHED_SUCCESS
);
1193 size_t string_length
;
1196 // retrieve both via mget
1197 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1198 test_true(rc
== MEMCACHED_SUCCESS
);
1200 char key
[MEMCACHED_MAX_KEY
];
1203 // this should get both
1204 for (int i
= 0; i
< 2; i
++)
1206 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1208 test_true(rc
== MEMCACHED_SUCCESS
);
1210 if (key_length
== 4)
1212 test_true(string_length
== strlen(values
[val
]));
1213 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1217 // this should indicate end
1218 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1219 test_true(rc
== MEMCACHED_END
);
1222 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1223 test_true(rc
== MEMCACHED_SUCCESS
);
1225 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1226 test_true(key_length
== lengths
[0]);
1227 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1228 test_true(string_length
== strlen(values
[0]));
1229 test_true(strncmp(values
[0], string
, string_length
) == 0);
1230 test_true(rc
== MEMCACHED_SUCCESS
);
1233 // this should indicate end
1234 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1235 test_true(rc
== MEMCACHED_END
);
1237 return TEST_SUCCESS
;
1240 /* Do not copy the style of this code, I just access hosts to testthis function */
1241 static test_return_t
stats_servername_test(memcached_st
*memc
)
1243 memcached_return_t rc
;
1244 memcached_stat_st memc_stat
;
1245 memcached_server_instance_st instance
=
1246 memcached_server_instance_by_position(memc
, 0);
1248 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
1249 if (memcached_get_sasl_callbacks(memc
) != NULL
)
1250 return TEST_SKIPPED
;
1252 rc
= memcached_stat_servername(&memc_stat
, NULL
,
1253 memcached_server_name(instance
),
1254 memcached_server_port(instance
));
1256 return TEST_SUCCESS
;
1259 static test_return_t
increment_test(memcached_st
*memc
)
1261 uint64_t new_number
;
1262 memcached_return_t rc
;
1263 const char *key
= "number";
1264 const char *value
= "0";
1266 rc
= memcached_set(memc
, key
, strlen(key
),
1267 value
, strlen(value
),
1268 (time_t)0, (uint32_t)0);
1269 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1271 rc
= memcached_increment(memc
, key
, strlen(key
),
1273 test_true(rc
== MEMCACHED_SUCCESS
);
1274 test_true(new_number
== 1);
1276 rc
= memcached_increment(memc
, key
, strlen(key
),
1278 test_true(rc
== MEMCACHED_SUCCESS
);
1279 test_true(new_number
== 2);
1281 return TEST_SUCCESS
;
1284 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1286 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1288 uint64_t new_number
;
1289 memcached_return_t rc
;
1290 const char *key
= "number";
1291 uint64_t initial
= 0;
1293 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1294 1, initial
, 0, &new_number
);
1295 test_true(rc
== MEMCACHED_SUCCESS
);
1296 test_true(new_number
== initial
);
1298 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1299 1, initial
, 0, &new_number
);
1300 test_true(rc
== MEMCACHED_SUCCESS
);
1301 test_true(new_number
== (initial
+ 1));
1303 return TEST_SUCCESS
;
1306 static test_return_t
decrement_test(memcached_st
*memc
)
1308 uint64_t new_number
;
1309 memcached_return_t rc
;
1310 const char *key
= "number";
1311 const char *value
= "3";
1313 rc
= memcached_set(memc
, key
, strlen(key
),
1314 value
, strlen(value
),
1315 (time_t)0, (uint32_t)0);
1316 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1318 rc
= memcached_decrement(memc
, key
, strlen(key
),
1320 test_true(rc
== MEMCACHED_SUCCESS
);
1321 test_true(new_number
== 2);
1323 rc
= memcached_decrement(memc
, key
, strlen(key
),
1325 test_true(rc
== MEMCACHED_SUCCESS
);
1326 test_true(new_number
== 1);
1328 return TEST_SUCCESS
;
1331 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1333 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1335 uint64_t new_number
;
1336 memcached_return_t rc
;
1337 const char *key
= "number";
1338 uint64_t initial
= 3;
1340 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1341 1, initial
, 0, &new_number
);
1342 test_true(rc
== MEMCACHED_SUCCESS
);
1343 test_true(new_number
== initial
);
1345 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1346 1, initial
, 0, &new_number
);
1347 test_true(rc
== MEMCACHED_SUCCESS
);
1348 test_true(new_number
== (initial
- 1));
1350 return TEST_SUCCESS
;
1353 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1355 uint64_t new_number
;
1356 memcached_return_t rc
;
1357 const char *master_key
= "foo";
1358 const char *key
= "number";
1359 const char *value
= "0";
1361 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1363 value
, strlen(value
),
1364 (time_t)0, (uint32_t)0);
1365 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1367 rc
= memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1369 test_true(rc
== MEMCACHED_SUCCESS
);
1370 test_true(new_number
== 1);
1372 rc
= memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1374 test_true(rc
== MEMCACHED_SUCCESS
);
1375 test_true(new_number
== 2);
1377 return TEST_SUCCESS
;
1380 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1382 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1384 uint64_t new_number
;
1385 memcached_return_t rc
;
1386 const char *master_key
= "foo";
1387 const char *key
= "number";
1388 uint64_t initial
= 0;
1390 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1392 1, initial
, 0, &new_number
);
1393 test_true(rc
== MEMCACHED_SUCCESS
);
1394 test_true(new_number
== initial
);
1396 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1398 1, initial
, 0, &new_number
);
1399 test_true(rc
== MEMCACHED_SUCCESS
);
1400 test_true(new_number
== (initial
+ 1));
1402 return TEST_SUCCESS
;
1405 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1407 uint64_t new_number
;
1408 memcached_return_t rc
;
1409 const char *master_key
= "foo";
1410 const char *key
= "number";
1411 const char *value
= "3";
1413 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1415 value
, strlen(value
),
1416 (time_t)0, (uint32_t)0);
1417 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1419 rc
= memcached_decrement_by_key(memc
, master_key
, strlen(master_key
),
1422 test_true(rc
== MEMCACHED_SUCCESS
);
1423 test_true(new_number
== 2);
1425 rc
= memcached_decrement_by_key(memc
, master_key
, strlen(master_key
),
1428 test_true(rc
== MEMCACHED_SUCCESS
);
1429 test_true(new_number
== 1);
1431 return TEST_SUCCESS
;
1434 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1436 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1438 uint64_t new_number
;
1439 memcached_return_t rc
;
1440 const char *master_key
= "foo";
1441 const char *key
= "number";
1442 uint64_t initial
= 3;
1444 rc
= memcached_decrement_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1446 1, initial
, 0, &new_number
);
1447 test_true(rc
== MEMCACHED_SUCCESS
);
1448 test_true(new_number
== initial
);
1450 rc
= memcached_decrement_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1452 1, initial
, 0, &new_number
);
1453 test_true(rc
== MEMCACHED_SUCCESS
);
1454 test_true(new_number
== (initial
- 1));
1456 return TEST_SUCCESS
;
1459 static test_return_t
quit_test(memcached_st
*memc
)
1461 memcached_return_t rc
;
1462 const char *key
= "fudge";
1463 const char *value
= "sanford and sun";
1465 rc
= memcached_set(memc
, key
, strlen(key
),
1466 value
, strlen(value
),
1467 (time_t)10, (uint32_t)3);
1468 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1469 memcached_quit(memc
);
1471 rc
= memcached_set(memc
, key
, strlen(key
),
1472 value
, strlen(value
),
1473 (time_t)50, (uint32_t)9);
1474 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1476 return TEST_SUCCESS
;
1479 static test_return_t
mget_result_test(memcached_st
*memc
)
1481 memcached_return_t rc
;
1482 const char *keys
[]= {"fudge", "son", "food"};
1483 size_t key_length
[]= {5, 3, 4};
1486 memcached_result_st results_obj
;
1487 memcached_result_st
*results
;
1489 results
= memcached_result_create(memc
, &results_obj
);
1491 test_true(&results_obj
== results
);
1493 /* We need to empty the server before continueing test */
1494 rc
= memcached_flush(memc
, 0);
1495 test_true(rc
== MEMCACHED_SUCCESS
);
1497 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1498 test_true(rc
== MEMCACHED_SUCCESS
);
1500 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1505 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1506 test_true(!results
);
1507 test_true(rc
== MEMCACHED_END
);
1509 for (x
= 0; x
< 3; x
++)
1511 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1512 keys
[x
], key_length
[x
],
1513 (time_t)50, (uint32_t)9);
1514 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1517 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1518 test_true(rc
== MEMCACHED_SUCCESS
);
1520 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1523 test_true(&results_obj
== results
);
1524 test_true(rc
== MEMCACHED_SUCCESS
);
1525 test_true(memcached_result_key_length(results
) == memcached_result_length(results
));
1526 test_true(!memcmp(memcached_result_key_value(results
),
1527 memcached_result_value(results
),
1528 memcached_result_length(results
)));
1531 memcached_result_free(&results_obj
);
1533 return TEST_SUCCESS
;
1536 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1538 memcached_return_t rc
;
1539 const char *keys
[]= {"fudge", "son", "food"};
1540 size_t key_length
[]= {5, 3, 4};
1543 memcached_result_st
*results
;
1545 /* We need to empty the server before continueing test */
1546 rc
= memcached_flush(memc
, 0);
1547 test_true(rc
== MEMCACHED_SUCCESS
);
1549 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1550 test_true(rc
== MEMCACHED_SUCCESS
);
1552 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
1556 test_true(!results
);
1557 test_true(rc
== MEMCACHED_END
);
1559 for (x
= 0; x
< 3; x
++)
1561 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1562 keys
[x
], key_length
[x
],
1563 (time_t)50, (uint32_t)9);
1564 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1567 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1568 test_true(rc
== MEMCACHED_SUCCESS
);
1571 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1574 test_true(rc
== MEMCACHED_SUCCESS
);
1575 test_true(memcached_result_key_length(results
) == memcached_result_length(results
));
1576 test_true(!memcmp(memcached_result_key_value(results
),
1577 memcached_result_value(results
),
1578 memcached_result_length(results
)));
1579 memcached_result_free(results
);
1583 return TEST_SUCCESS
;
1586 /* Count the results */
1587 static memcached_return_t
callback_counter(const memcached_st
*ptr
,
1588 memcached_result_st
*result
,
1591 (void)ptr
; (void)result
;
1592 size_t *counter
= (size_t *)context
;
1594 *counter
= *counter
+ 1;
1596 return MEMCACHED_SUCCESS
;
1599 static test_return_t
mget_result_function(memcached_st
*memc
)
1601 memcached_return_t rc
;
1602 const char *keys
[]= {"fudge", "son", "food"};
1603 size_t key_length
[]= {5, 3, 4};
1606 memcached_execute_fn callbacks
[1];
1608 /* We need to empty the server before continueing test */
1609 rc
= memcached_flush(memc
, 0);
1610 for (x
= 0; x
< 3; x
++)
1612 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1613 keys
[x
], key_length
[x
],
1614 (time_t)50, (uint32_t)9);
1615 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1618 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1619 test_true(rc
== MEMCACHED_SUCCESS
);
1621 callbacks
[0]= &callback_counter
;
1623 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1625 test_true(counter
== 3);
1627 return TEST_SUCCESS
;
1630 static test_return_t
mget_test(memcached_st
*memc
)
1632 memcached_return_t rc
;
1633 const char *keys
[]= {"fudge", "son", "food"};
1634 size_t key_length
[]= {5, 3, 4};
1638 char return_key
[MEMCACHED_MAX_KEY
];
1639 size_t return_key_length
;
1641 size_t return_value_length
;
1643 /* We need to empty the server before continueing test */
1644 rc
= memcached_flush(memc
, 0);
1645 test_true(rc
== MEMCACHED_SUCCESS
);
1647 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1648 test_true(rc
== MEMCACHED_SUCCESS
);
1650 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1651 &return_value_length
, &flags
, &rc
)) != NULL
)
1653 test_true(return_value
);
1655 test_true(!return_value
);
1656 test_true(return_value_length
== 0);
1657 test_true(rc
== MEMCACHED_END
);
1659 for (x
= 0; x
< 3; x
++)
1661 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1662 keys
[x
], key_length
[x
],
1663 (time_t)50, (uint32_t)9);
1664 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1667 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1668 test_true(rc
== MEMCACHED_SUCCESS
);
1671 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1672 &return_value_length
, &flags
, &rc
)))
1674 test_true(return_value
);
1675 test_true(rc
== MEMCACHED_SUCCESS
);
1676 test_true(return_key_length
== return_value_length
);
1677 test_true(!memcmp(return_value
, return_key
, return_value_length
));
1682 return TEST_SUCCESS
;
1685 static test_return_t
mget_execute(memcached_st
*memc
)
1689 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1693 * I only want to hit _one_ server so I know the number of requests I'm
1694 * sending in the pipeline.
1696 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1697 memc
->number_of_hosts
= 1;
1699 size_t max_keys
= 20480;
1702 char **keys
= calloc(max_keys
, sizeof(char*));
1703 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
1705 /* First add all of the items.. */
1706 char blob
[1024] = {0};
1707 memcached_return_t rc
;
1709 for (size_t x
= 0; x
< max_keys
; ++x
)
1713 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1715 test_true(keys
[x
] != NULL
);
1716 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1717 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1720 /* Try to get all of them with a large multiget */
1722 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
1723 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1724 max_keys
, callbacks
, &counter
, 1);
1726 if (rc
== MEMCACHED_SUCCESS
)
1729 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1730 test_true(rc
== MEMCACHED_END
);
1732 /* Verify that we got all of the items */
1733 test_true(counter
== max_keys
);
1735 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1737 test_true(counter
== 0);
1741 test_fail("note: this test functions differently when in binary mode");
1744 /* Release all allocated resources */
1745 for (size_t x
= 0; x
< max_keys
; ++x
)
1752 memc
->number_of_hosts
= number_of_hosts
;
1753 return TEST_SUCCESS
;
1756 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1758 static test_return_t
key_setup(memcached_st
*memc
)
1762 if (pre_binary(memc
) != TEST_SUCCESS
)
1763 return TEST_SKIPPED
;
1765 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1767 return TEST_SUCCESS
;
1770 static test_return_t
key_teardown(memcached_st
*memc
)
1773 pairs_free(global_pairs
);
1775 return TEST_SUCCESS
;
1778 static test_return_t
block_add_regression(memcached_st
*memc
)
1780 /* First add all of the items.. */
1781 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1783 memcached_return_t rc
;
1784 char blob
[1024] = {0};
1786 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1787 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1790 return TEST_SUCCESS
;
1793 static test_return_t
binary_add_regression(memcached_st
*memc
)
1795 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1796 test_return_t rc
= block_add_regression(memc
);
1797 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1801 static test_return_t
get_stats_keys(memcached_st
*memc
)
1805 memcached_stat_st memc_stat
;
1806 memcached_return_t rc
;
1808 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1809 test_true(rc
== MEMCACHED_SUCCESS
);
1810 for (ptr
= stat_list
; *ptr
; ptr
++)
1815 return TEST_SUCCESS
;
1818 static test_return_t
version_string_test(memcached_st
*memc
)
1820 const char *version_string
;
1823 version_string
= memcached_lib_version();
1825 test_true(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1827 return TEST_SUCCESS
;
1830 static test_return_t
get_stats(memcached_st
*memc
)
1834 memcached_return_t rc
;
1835 memcached_stat_st
*memc_stat
;
1837 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1838 test_true(rc
== MEMCACHED_SUCCESS
);
1840 test_true(rc
== MEMCACHED_SUCCESS
);
1841 test_true(memc_stat
);
1843 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1845 stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1846 test_true(rc
== MEMCACHED_SUCCESS
);
1847 for (ptr
= stat_list
; *ptr
; ptr
++);
1852 memcached_stat_free(NULL
, memc_stat
);
1854 return TEST_SUCCESS
;
1857 static test_return_t
add_host_test(memcached_st
*memc
)
1860 memcached_server_st
*servers
;
1861 memcached_return_t rc
;
1862 char servername
[]= "0.example.com";
1864 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1866 test_true(1 == memcached_server_list_count(servers
));
1868 for (x
= 2; x
< 20; x
++)
1870 char buffer
[SMALL_STRING_LEN
];
1872 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1873 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1875 test_true(rc
== MEMCACHED_SUCCESS
);
1876 test_true(x
== memcached_server_list_count(servers
));
1879 rc
= memcached_server_push(memc
, servers
);
1880 test_true(rc
== MEMCACHED_SUCCESS
);
1881 rc
= memcached_server_push(memc
, servers
);
1882 test_true(rc
== MEMCACHED_SUCCESS
);
1884 memcached_server_list_free(servers
);
1886 return TEST_SUCCESS
;
1889 static memcached_return_t
clone_test_callback(memcached_st
*parent
, memcached_st
*memc_clone
)
1891 (void)parent
;(void)memc_clone
;
1892 return MEMCACHED_SUCCESS
;
1895 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
)
1898 return MEMCACHED_SUCCESS
;
1901 static test_return_t
callback_test(memcached_st
*memc
)
1903 /* Test User Data */
1907 memcached_return_t rc
;
1909 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1910 test_true(rc
== MEMCACHED_SUCCESS
);
1911 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1912 test_true(*test_ptr
== x
);
1915 /* Test Clone Callback */
1917 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1918 void *clone_cb_ptr
= *(void **)&clone_cb
;
1919 void *temp_function
= NULL
;
1920 memcached_return_t rc
;
1922 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1924 test_true(rc
== MEMCACHED_SUCCESS
);
1925 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1926 test_true(temp_function
== clone_cb_ptr
);
1929 /* Test Cleanup Callback */
1931 memcached_cleanup_fn cleanup_cb
=
1932 (memcached_cleanup_fn
)cleanup_test_callback
;
1933 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1934 void *temp_function
= NULL
;
1935 memcached_return_t rc
;
1937 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1939 test_true(rc
== MEMCACHED_SUCCESS
);
1940 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1941 test_true(temp_function
== cleanup_cb_ptr
);
1944 return TEST_SUCCESS
;
1947 /* We don't test the behavior itself, we test the switches */
1948 static test_return_t
behavior_test(memcached_st
*memc
)
1953 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1954 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1955 test_true(value
== 1);
1957 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1958 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1959 test_true(value
== 1);
1961 set
= MEMCACHED_HASH_MD5
;
1962 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1963 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1964 test_true(value
== MEMCACHED_HASH_MD5
);
1968 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1969 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1970 test_true(value
== 0);
1972 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1973 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1974 test_true(value
== 0);
1976 set
= MEMCACHED_HASH_DEFAULT
;
1977 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1978 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1979 test_true(value
== MEMCACHED_HASH_DEFAULT
);
1981 set
= MEMCACHED_HASH_CRC
;
1982 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1983 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1984 test_true(value
== MEMCACHED_HASH_CRC
);
1986 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1987 test_true(value
> 0);
1989 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1990 test_true(value
> 0);
1992 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
1993 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
1994 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
1996 return TEST_SUCCESS
;
1999 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2001 memcached_return_t rc
;
2005 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
2006 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2008 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2010 if (rc
== MEMCACHED_SUCCESS
)
2012 test_true((bool)value
== set
);
2016 test_false((bool)value
== set
);
2019 return TEST_SUCCESS
;
2023 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2025 memcached_return_t rc
;
2029 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, set
);
2030 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2032 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2034 if (rc
== MEMCACHED_SUCCESS
)
2036 test_true((bool)value
== set
);
2040 test_false((bool)value
== set
);
2043 return TEST_SUCCESS
;
2047 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2049 memcached_return_t rc
;
2053 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, set
);
2054 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2056 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2058 if (rc
== MEMCACHED_SUCCESS
)
2060 test_true((bool)value
== set
);
2064 test_false((bool)value
== set
);
2067 return TEST_SUCCESS
;
2070 static test_return_t
fetch_all_results(memcached_st
*memc
, size_t *keys_returned
)
2072 memcached_return_t rc
= MEMCACHED_SUCCESS
;
2073 char return_key
[MEMCACHED_MAX_KEY
];
2074 size_t return_key_length
;
2076 size_t return_value_length
;
2081 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2082 &return_value_length
, &flags
, &rc
)))
2084 test_true(return_value
);
2085 test_true(rc
== MEMCACHED_SUCCESS
);
2087 *keys_returned
= *keys_returned
+1;
2090 test_true_got(rc
== MEMCACHED_END
|| rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
2092 return TEST_SUCCESS
;
2095 /* Test case provided by Cal Haldenbrand */
2096 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2098 unsigned int setter
= 1;
2100 unsigned long long total
= 0;
2103 char randomstuff
[6 * 1024];
2104 memcached_return_t rc
;
2106 memset(randomstuff
, 0, 6 * 1024);
2108 /* We just keep looking at the same values over and over */
2111 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2112 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2116 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2120 size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2121 memset(randomstuff
, 0, 6 * 1024);
2122 test_true(size
< 6 * 1024); /* Being safe here */
2124 for (j
= 0 ; j
< size
;j
++)
2125 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2128 snprintf(key
, sizeof(key
), "%u", x
);
2129 rc
= memcached_set(memc
, key
, strlen(key
),
2130 randomstuff
, strlen(randomstuff
), 10, 0);
2131 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2132 /* If we fail, lets try again */
2133 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
2134 rc
= memcached_set(memc
, key
, strlen(key
),
2135 randomstuff
, strlen(randomstuff
), 10, 0);
2136 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2139 return TEST_SUCCESS
;
2142 /* Test case provided by Cal Haldenbrand */
2143 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2145 unsigned int setter
;
2149 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2150 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2152 setter
= 20 * 1024576;
2153 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2154 setter
= 20 * 1024576;
2155 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2156 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2157 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2159 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2162 for (uint32_t x
= 0, errors
= 0; total
< 24576 ; x
++)
2164 memcached_return_t rc
= MEMCACHED_SUCCESS
;
2165 char buffer
[SMALL_STRING_LEN
];
2170 memset(buffer
, 0, SMALL_STRING_LEN
);
2172 snprintf(buffer
, sizeof(buffer
), "%u", x
);
2173 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
2174 &val_len
, &flags
, &rc
);
2175 if (rc
!= MEMCACHED_SUCCESS
)
2177 if (rc
== MEMCACHED_NOTFOUND
)
2191 return TEST_SUCCESS
;
2194 /* Do a large mget() over all the keys we think exist */
2195 #define KEY_COUNT 3000 // * 1024576
2196 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2198 memcached_return_t rc
;
2199 unsigned int setter
;
2202 size_t key_lengths
[KEY_COUNT
];
2205 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2206 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2208 setter
= 20 * 1024576;
2209 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2210 setter
= 20 * 1024576;
2211 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2212 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2213 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2216 keys
= calloc(KEY_COUNT
, sizeof(char *));
2218 for (x
= 0; x
< KEY_COUNT
; x
++)
2222 snprintf(buffer
, 30, "%u", x
);
2223 keys
[x
]= strdup(buffer
);
2224 key_lengths
[x
]= strlen(keys
[x
]);
2227 rc
= memcached_mget(memc
, (const char **)keys
, key_lengths
, KEY_COUNT
);
2228 test_true(rc
== MEMCACHED_SUCCESS
);
2230 size_t keys_returned
;
2231 test_true(fetch_all_results(memc
, &keys_returned
) == TEST_SUCCESS
);
2233 for (x
= 0; x
< KEY_COUNT
; x
++)
2237 return TEST_SUCCESS
;
2240 /* Make sure we behave properly if server list has no values */
2241 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2243 memcached_return_t rc
;
2244 const char *keys
[]= {"fudge", "son", "food"};
2245 size_t key_length
[]= {5, 3, 4};
2248 char return_key
[MEMCACHED_MAX_KEY
];
2249 size_t return_key_length
;
2251 size_t return_value_length
;
2253 /* Here we free everything before running a bunch of mget tests */
2254 memcached_servers_reset(memc
);
2257 /* We need to empty the server before continueing test */
2258 rc
= memcached_flush(memc
, 0);
2259 test_true(rc
== MEMCACHED_NO_SERVERS
);
2261 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2262 test_true(rc
== MEMCACHED_NO_SERVERS
);
2264 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2265 &return_value_length
, &flags
, &rc
)) != NULL
)
2267 test_true(return_value
);
2269 test_true(!return_value
);
2270 test_true(return_value_length
== 0);
2271 test_true(rc
== MEMCACHED_NO_SERVERS
);
2273 for (x
= 0; x
< 3; x
++)
2275 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2276 keys
[x
], key_length
[x
],
2277 (time_t)50, (uint32_t)9);
2278 test_true(rc
== MEMCACHED_NO_SERVERS
);
2281 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2282 test_true(rc
== MEMCACHED_NO_SERVERS
);
2285 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2286 &return_value_length
, &flags
, &rc
)))
2288 test_true(return_value
);
2289 test_true(rc
== MEMCACHED_SUCCESS
);
2290 test_true(return_key_length
== return_value_length
);
2291 test_true(!memcmp(return_value
, return_key
, return_value_length
));
2296 return TEST_SUCCESS
;
2299 #define VALUE_SIZE_BUG5 1048064
2300 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2302 memcached_return_t rc
;
2303 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2304 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2305 char return_key
[MEMCACHED_MAX_KEY
];
2306 size_t return_key_length
;
2308 size_t value_length
;
2312 char insert_data
[VALUE_SIZE_BUG5
];
2314 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2315 insert_data
[x
]= (signed char)rand();
2317 memcached_flush(memc
, 0);
2318 value
= memcached_get(memc
, keys
[0], key_length
[0],
2319 &value_length
, &flags
, &rc
);
2320 test_true(value
== NULL
);
2321 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2324 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2325 &value_length
, &flags
, &rc
)))
2327 test_true(count
== 0);
2329 for (x
= 0; x
< 4; x
++)
2331 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2332 insert_data
, VALUE_SIZE_BUG5
,
2333 (time_t)0, (uint32_t)0);
2334 test_true(rc
== MEMCACHED_SUCCESS
);
2337 for (x
= 0; x
< 10; x
++)
2339 value
= memcached_get(memc
, keys
[0], key_length
[0],
2340 &value_length
, &flags
, &rc
);
2344 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2346 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2347 &value_length
, &flags
, &rc
)))
2352 test_true(count
== 4);
2355 return TEST_SUCCESS
;
2358 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2360 memcached_return_t rc
;
2361 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2362 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2363 char return_key
[MEMCACHED_MAX_KEY
];
2364 size_t return_key_length
;
2366 size_t value_length
;
2370 char insert_data
[VALUE_SIZE_BUG5
];
2372 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2373 insert_data
[x
]= (signed char)rand();
2375 memcached_flush(memc
, 0);
2376 value
= memcached_get(memc
, keys
[0], key_length
[0],
2377 &value_length
, &flags
, &rc
);
2378 test_true(value
== NULL
);
2379 test_true(rc
== MEMCACHED_NOTFOUND
);
2380 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2381 test_true(rc
== MEMCACHED_SUCCESS
);
2384 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2385 &value_length
, &flags
, &rc
)))
2387 test_true(count
== 0);
2388 test_true(rc
== MEMCACHED_END
);
2390 for (x
= 0; x
< 4; x
++)
2392 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2393 insert_data
, VALUE_SIZE_BUG5
,
2394 (time_t)0, (uint32_t)0);
2395 test_true(rc
== MEMCACHED_SUCCESS
);
2398 for (x
= 0; x
< 2; x
++)
2400 value
= memcached_get(memc
, keys
[0], key_length
[0],
2401 &value_length
, &flags
, &rc
);
2405 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2406 test_true(rc
== MEMCACHED_SUCCESS
);
2408 /* We test for purge of partial complete fetches */
2409 for (count
= 3; count
; count
--)
2411 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2412 &value_length
, &flags
, &rc
);
2413 test_true(rc
== MEMCACHED_SUCCESS
);
2414 test_true(!(memcmp(value
, insert_data
, value_length
)));
2415 test_true(value_length
);
2420 return TEST_SUCCESS
;
2423 static test_return_t
user_supplied_bug8(memcached_st
*memc
)
2425 memcached_return_t rc
;
2427 memcached_st
*memc_clone
;
2429 memcached_server_st
*servers
;
2430 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";
2433 servers
= memcached_servers_parse(server_list
);
2436 mine
= memcached_create(NULL
);
2437 rc
= memcached_server_push(mine
, servers
);
2438 test_true(rc
== MEMCACHED_SUCCESS
);
2439 memcached_server_list_free(servers
);
2442 memc_clone
= memcached_clone(NULL
, mine
);
2444 memcached_quit(mine
);
2445 memcached_quit(memc_clone
);
2448 memcached_free(mine
);
2449 memcached_free(memc_clone
);
2451 return TEST_SUCCESS
;
2454 /* Test flag store/retrieve */
2455 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2457 memcached_return_t rc
;
2458 const char *keys
= "036790384900";
2459 size_t key_length
= strlen(keys
);
2460 char return_key
[MEMCACHED_MAX_KEY
];
2461 size_t return_key_length
;
2463 size_t value_length
;
2466 char insert_data
[VALUE_SIZE_BUG5
];
2468 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2469 insert_data
[x
]= (signed char)rand();
2471 memcached_flush(memc
, 0);
2474 rc
= memcached_set(memc
, keys
, key_length
,
2475 insert_data
, VALUE_SIZE_BUG5
,
2477 test_true(rc
== MEMCACHED_SUCCESS
);
2480 value
= memcached_get(memc
, keys
, key_length
,
2481 &value_length
, &flags
, &rc
);
2482 test_true(flags
== 245);
2486 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2489 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2490 &value_length
, &flags
, &rc
);
2491 test_true(flags
== 245);
2496 return TEST_SUCCESS
;
2499 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2501 memcached_return_t rc
;
2502 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2503 size_t key_length
[3];
2508 char return_key
[MEMCACHED_MAX_KEY
];
2509 size_t return_key_length
;
2511 size_t return_value_length
;
2514 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2515 key_length
[1]= strlen("fudge&*@#");
2516 key_length
[2]= strlen("for^#@&$not");
2519 for (x
= 0; x
< 3; x
++)
2521 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2522 keys
[x
], key_length
[x
],
2523 (time_t)50, (uint32_t)9);
2524 test_true(rc
== MEMCACHED_SUCCESS
);
2527 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2528 test_true(rc
== MEMCACHED_SUCCESS
);
2530 /* We need to empty the server before continueing test */
2531 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2532 &return_value_length
, &flags
, &rc
)) != NULL
)
2534 test_true(return_value
);
2538 test_true(count
== 3);
2540 return TEST_SUCCESS
;
2543 /* We are testing with aggressive timeout to get failures */
2544 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2546 const char *key
= "foo";
2548 size_t value_length
= 512;
2551 memcached_return_t rc
;
2552 unsigned int set
= 1;
2553 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2556 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2557 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2559 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2562 value
= (char*)malloc(value_length
* sizeof(char));
2564 for (x
= 0; x
< value_length
; x
++)
2565 value
[x
]= (char) (x
% 127);
2567 for (x
= 1; x
<= 100000; ++x
)
2569 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2571 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2572 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2574 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2579 memcached_free(mclone
);
2581 return TEST_SUCCESS
;
2585 We are looking failures in the async protocol
2587 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2589 const char *key
= "foo";
2591 size_t value_length
= 512;
2594 memcached_return_t rc
;
2595 unsigned int set
= 1;
2597 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2599 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2600 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2602 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2605 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2607 test_true(timeout
== -1);
2609 value
= (char*)malloc(value_length
* sizeof(char));
2611 for (x
= 0; x
< value_length
; x
++)
2612 value
[x
]= (char) (x
% 127);
2614 for (x
= 1; x
<= 100000; ++x
)
2616 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2620 memcached_free(mclone
);
2622 return TEST_SUCCESS
;
2626 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2628 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2630 memcached_return_t rc
;
2632 size_t value_length
;
2634 uint64_t number_value
;
2636 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2637 &value_length
, &flags
, &rc
);
2638 test_true(value
== NULL
);
2639 test_true(rc
== MEMCACHED_NOTFOUND
);
2641 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2644 test_true(value
== NULL
);
2645 /* The binary protocol will set the key if it doesn't exist */
2646 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2648 test_true(rc
== MEMCACHED_SUCCESS
);
2652 test_true(rc
== MEMCACHED_NOTFOUND
);
2655 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2657 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2658 &value_length
, &flags
, &rc
);
2660 test_true(rc
== MEMCACHED_SUCCESS
);
2663 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2665 test_true(number_value
== 2);
2666 test_true(rc
== MEMCACHED_SUCCESS
);
2668 return TEST_SUCCESS
;
2672 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2673 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2675 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2677 char key
[] = "key34567890";
2679 memcached_return_t rc
;
2680 size_t overflowSize
;
2682 char commandFirst
[]= "set key34567890 0 0 ";
2683 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2684 size_t commandLength
;
2687 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2689 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2691 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2693 overflow
= malloc(testSize
);
2694 test_true(overflow
!= NULL
);
2696 memset(overflow
, 'x', testSize
);
2697 rc
= memcached_set(memc
, key
, strlen(key
),
2698 overflow
, testSize
, 0, 0);
2699 test_true(rc
== MEMCACHED_SUCCESS
);
2703 return TEST_SUCCESS
;
2708 Test values of many different sizes
2709 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2710 set key34567890 0 0 8169 \r\n
2711 is sent followed by buffer of size 8169, followed by 8169
2713 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2716 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2717 memcached_return_t rc
;
2718 const char *key
= "foo";
2720 size_t value_length
= 18000;
2722 size_t string_length
;
2725 size_t current_length
;
2727 value
= (char*)malloc(value_length
);
2730 for (x
= 0; x
< value_length
; x
++)
2731 value
[x
] = (char) (x
% 127);
2733 for (current_length
= 0; current_length
< value_length
; current_length
++)
2735 rc
= memcached_set(memc
, key
, strlen(key
),
2736 value
, current_length
,
2737 (time_t)0, (uint32_t)0);
2738 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2740 string
= memcached_get(memc
, key
, strlen(key
),
2741 &string_length
, &flags
, &rc
);
2743 test_true(rc
== MEMCACHED_SUCCESS
);
2744 test_true(string_length
== current_length
);
2745 test_true(!memcmp(string
, value
, string_length
));
2752 return TEST_SUCCESS
;
2756 Look for zero length value problems
2758 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2761 memcached_return_t rc
;
2762 const char *key
= "mykey";
2767 for (x
= 0; x
< 2; x
++)
2769 rc
= memcached_set(memc
, key
, strlen(key
),
2771 (time_t)0, (uint32_t)0);
2773 test_true(rc
== MEMCACHED_SUCCESS
);
2775 value
= memcached_get(memc
, key
, strlen(key
),
2776 &length
, &flags
, &rc
);
2778 test_true(rc
== MEMCACHED_SUCCESS
);
2779 test_true(value
== NULL
);
2780 test_true(length
== 0);
2781 test_true(flags
== 0);
2783 value
= memcached_get(memc
, key
, strlen(key
),
2784 &length
, &flags
, &rc
);
2786 test_true(rc
== MEMCACHED_SUCCESS
);
2787 test_true(value
== NULL
);
2788 test_true(length
== 0);
2789 test_true(flags
== 0);
2792 return TEST_SUCCESS
;
2795 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2796 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2798 memcached_return_t rc
;
2799 const char *key
= "mykey";
2804 rc
= memcached_set(memc
, key
, strlen(key
),
2806 (time_t)0, UINT32_MAX
);
2808 test_true(rc
== MEMCACHED_SUCCESS
);
2810 value
= memcached_get(memc
, key
, strlen(key
),
2811 &length
, &flags
, &rc
);
2813 test_true(rc
== MEMCACHED_SUCCESS
);
2814 test_true(value
== NULL
);
2815 test_true(length
== 0);
2816 test_true(flags
== UINT32_MAX
);
2818 return TEST_SUCCESS
;
2821 #if !defined(__sun) && !defined(__OpenBSD__)
2822 /* Check the validity of chinese key*/
2823 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2825 memcached_return_t rc
;
2826 const char *key
= "豆瓣";
2827 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2832 rc
= memcached_set(memc
, key
, strlen(key
),
2833 value
, strlen(value
),
2836 test_true(rc
== MEMCACHED_SUCCESS
);
2838 value2
= memcached_get(memc
, key
, strlen(key
),
2839 &length
, &flags
, &rc
);
2841 test_true(length
==strlen(value
));
2842 test_true(rc
== MEMCACHED_SUCCESS
);
2843 test_true(memcmp(value
, value2
, length
)==0);
2846 return TEST_SUCCESS
;
2854 static test_return_t
user_supplied_bug19(memcached_st
*not_used
)
2857 const memcached_server_st
*server
;
2858 memcached_return_t res
;
2862 memc
= memcached_create(NULL
);
2863 memcached_server_add_with_weight(memc
, "localhost", 11311, 100);
2864 memcached_server_add_with_weight(memc
, "localhost", 11312, 100);
2866 server
= memcached_server_by_key(memc
, "a", 1, &res
);
2868 memcached_free(memc
);
2870 return TEST_SUCCESS
;
2873 /* CAS test from Andei */
2874 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2876 memcached_return_t status
;
2877 memcached_result_st
*result
, result_obj
;
2878 const char *key
= "abc";
2879 size_t key_len
= strlen("abc");
2880 const char *value
= "foobar";
2881 size_t value_len
= strlen(value
);
2883 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2885 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2886 test_true(status
== MEMCACHED_SUCCESS
);
2888 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2889 test_true(status
== MEMCACHED_SUCCESS
);
2891 result
= memcached_result_create(memc
, &result_obj
);
2894 memcached_result_create(memc
, &result_obj
);
2895 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2898 test_true(status
== MEMCACHED_SUCCESS
);
2900 memcached_result_free(result
);
2902 return TEST_SUCCESS
;
2905 #include "ketama_test_cases.h"
2906 static test_return_t
user_supplied_bug18(memcached_st
*trash
)
2908 memcached_return_t rc
;
2911 memcached_server_st
*server_pool
;
2916 memc
= memcached_create(NULL
);
2919 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2920 test_true(rc
== MEMCACHED_SUCCESS
);
2922 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2923 test_true(value
== 1);
2925 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2926 test_true(rc
== MEMCACHED_SUCCESS
);
2928 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2929 test_true(value
== MEMCACHED_HASH_MD5
);
2931 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");
2932 memcached_server_push(memc
, server_pool
);
2934 /* verify that the server list was parsed okay. */
2935 test_true(memcached_server_count(memc
) == 8);
2936 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2937 test_true(server_pool
[0].port
== 11211);
2938 test_true(server_pool
[0].weight
== 600);
2939 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2940 test_true(server_pool
[2].port
== 11211);
2941 test_true(server_pool
[2].weight
== 200);
2942 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2943 test_true(server_pool
[7].port
== 11211);
2944 test_true(server_pool
[7].weight
== 100);
2946 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2947 * us test the boundary wraparound.
2949 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
2951 /* verify the standard ketama set. */
2952 for (x
= 0; x
< 99; x
++)
2954 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2956 memcached_server_instance_st instance
=
2957 memcached_server_instance_by_position(memc
, server_idx
);
2959 const char *hostname
= memcached_server_name(instance
);
2960 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
2963 memcached_server_list_free(server_pool
);
2964 memcached_free(memc
);
2966 return TEST_SUCCESS
;
2969 /* Large mget() of missing keys with binary proto
2971 * If many binary quiet commands (such as getq's in an mget) fill the output
2972 * buffer and the server chooses not to respond, memcached_flush hangs. See
2973 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2976 /* sighandler_t function that always asserts false */
2977 static void fail(int unused
)
2984 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2989 return TEST_SKIPPED
;
2991 memcached_return_t rc
;
2994 size_t* key_lengths
;
2995 void (*oldalarm
)(int);
2996 memcached_st
*memc_clone
;
2998 memc_clone
= memcached_clone(NULL
, memc
);
2999 test_true(memc_clone
);
3001 /* only binproto uses getq for mget */
3002 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3004 /* empty the cache to ensure misses (hence non-responses) */
3005 rc
= memcached_flush(memc_clone
, 0);
3006 test_true(rc
== MEMCACHED_SUCCESS
);
3008 key_lengths
= calloc(key_count
, sizeof(size_t));
3009 keys
= calloc(key_count
, sizeof(char *));
3011 for (x
= 0; x
< key_count
; x
++)
3015 snprintf(buffer
, 30, "%u", x
);
3016 keys
[x
]= strdup(buffer
);
3017 key_lengths
[x
]= strlen(keys
[x
]);
3020 oldalarm
= signal(SIGALRM
, fail
);
3023 rc
= memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
);
3024 test_true(rc
== MEMCACHED_SUCCESS
);
3027 signal(SIGALRM
, oldalarm
);
3029 size_t keys_returned
;
3030 test_true(fetch_all_results(memc
, &keys_returned
) == TEST_SUCCESS
);
3032 for (x
= 0; x
< key_count
; x
++)
3037 memcached_free(memc_clone
);
3039 return TEST_SUCCESS
;
3043 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3045 test_return_t test_rc
;
3046 test_rc
= pre_binary(memc
);
3048 if (test_rc
!= TEST_SUCCESS
)
3053 /* should work as of r580 */
3054 rc
= _user_supplied_bug21(memc
, 10);
3055 test_true(rc
== TEST_SUCCESS
);
3057 /* should fail as of r580 */
3058 rc
= _user_supplied_bug21(memc
, 1000);
3059 test_true(rc
== TEST_SUCCESS
);
3061 return TEST_SUCCESS
;
3064 static test_return_t
auto_eject_hosts(memcached_st
*trash
)
3067 memcached_server_instance_st instance
;
3069 memcached_return_t rc
;
3070 memcached_st
*memc
= memcached_create(NULL
);
3073 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3074 test_true(rc
== MEMCACHED_SUCCESS
);
3076 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3077 test_true(value
== 1);
3079 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3080 test_true(rc
== MEMCACHED_SUCCESS
);
3082 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3083 test_true(value
== MEMCACHED_HASH_MD5
);
3085 /* server should be removed when in delay */
3086 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
3087 test_true(rc
== MEMCACHED_SUCCESS
);
3089 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
3090 test_true(value
== 1);
3092 memcached_server_st
*server_pool
;
3093 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");
3094 memcached_server_push(memc
, server_pool
);
3096 /* verify that the server list was parsed okay. */
3097 test_true(memcached_server_count(memc
) == 8);
3098 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
3099 test_true(server_pool
[0].port
== 11211);
3100 test_true(server_pool
[0].weight
== 600);
3101 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
3102 test_true(server_pool
[2].port
== 11211);
3103 test_true(server_pool
[2].weight
== 200);
3104 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
3105 test_true(server_pool
[7].port
== 11211);
3106 test_true(server_pool
[7].weight
== 100);
3108 instance
= memcached_server_instance_by_position(memc
, 2);
3109 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) + 15;
3110 memc
->ketama
.next_distribution_rebuild
= time(NULL
) - 1;
3113 This would not work if there were only two hosts.
3115 for (size_t x
= 0; x
< 99; x
++)
3117 memcached_autoeject(memc
);
3118 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3119 test_true(server_idx
!= 2);
3122 /* and re-added when it's back. */
3123 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) - 1;
3124 memc
->ketama
.next_distribution_rebuild
= time(NULL
) - 1;
3125 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
,
3126 memc
->distribution
);
3127 for (size_t x
= 0; x
< 99; x
++)
3129 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3130 // We re-use instance from above.
3132 memcached_server_instance_by_position(memc
, server_idx
);
3133 const char *hostname
= memcached_server_name(instance
);
3134 test_true(strcmp(hostname
, ketama_test_cases
[x
].server
) == 0);
3137 memcached_server_list_free(server_pool
);
3138 memcached_free(memc
);
3140 return TEST_SUCCESS
;
3143 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
3147 memcached_return_t rc
;
3148 memcached_st
*memc
= memcached_create(NULL
);
3152 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3153 test_true(rc
== MEMCACHED_SUCCESS
);
3155 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3156 test_true(value
== 1);
3158 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3159 test_true(rc
== MEMCACHED_SUCCESS
);
3161 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3162 test_true(value
== MEMCACHED_HASH_MD5
);
3165 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3167 memcached_server_st
*server_pool
;
3168 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");
3169 memcached_server_push(memc
, server_pool
);
3171 // @todo this needs to be refactored to actually test something.
3174 if ((fp
= fopen("ketama_keys.txt", "w")))
3178 printf("cannot write to file ketama_keys.txt");
3179 return TEST_FAILURE
;
3182 for (int x
= 0; x
< 10000; x
++)
3185 snprintf(key
, sizeof(key
), "%d", x
);
3187 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3188 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3189 in_port_t port
= memc
->hosts
[server_idx
].port
;
3190 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3191 memcached_server_instance_st instance
=
3192 memcached_server_instance_by_position(memc
, host_index
);
3196 memcached_server_list_free(server_pool
);
3197 memcached_free(memc
);
3199 return TEST_SUCCESS
;
3203 static test_return_t
result_static(memcached_st
*memc
)
3205 memcached_result_st result
;
3206 memcached_result_st
*result_ptr
;
3208 result_ptr
= memcached_result_create(memc
, &result
);
3209 test_true(result
.options
.is_allocated
== false);
3210 test_true(memcached_is_initialized(&result
) == true);
3211 test_true(result_ptr
);
3212 test_true(result_ptr
== &result
);
3214 memcached_result_free(&result
);
3216 test_true(result
.options
.is_allocated
== false);
3217 test_true(memcached_is_initialized(&result
) == false);
3219 return TEST_SUCCESS
;
3222 static test_return_t
result_alloc(memcached_st
*memc
)
3224 memcached_result_st
*result_ptr
;
3226 result_ptr
= memcached_result_create(memc
, NULL
);
3227 test_true(result_ptr
);
3228 test_true(result_ptr
->options
.is_allocated
== true);
3229 test_true(memcached_is_initialized(result_ptr
) == true);
3230 memcached_result_free(result_ptr
);
3232 return TEST_SUCCESS
;
3235 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3238 pairs_free(global_pairs
);
3240 return TEST_SUCCESS
;
3243 static test_return_t
generate_pairs(memcached_st
*memc
)
3246 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3247 global_count
= GLOBAL_COUNT
;
3249 for (size_t x
= 0; x
< global_count
; x
++)
3251 global_keys
[x
]= global_pairs
[x
].key
;
3252 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3255 return TEST_SUCCESS
;
3258 static test_return_t
generate_large_pairs(memcached_st
*memc
)
3261 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3262 global_count
= GLOBAL2_COUNT
;
3264 for (size_t x
= 0; x
< global_count
; x
++)
3266 global_keys
[x
]= global_pairs
[x
].key
;
3267 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3270 return TEST_SUCCESS
;
3273 static test_return_t
generate_data(memcached_st
*memc
)
3275 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3277 test_true(check_execute
== global_count
);
3279 return TEST_SUCCESS
;
3282 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3284 memcached_stat_st
*stat_p
;
3285 memcached_return_t rc
;
3286 uint32_t host_index
= 0;
3287 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3289 test_true(check_execute
== global_count
);
3291 //TODO: hosts used size stats
3292 stat_p
= memcached_stat(memc
, NULL
, &rc
);
3295 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3297 /* This test was changes so that "make test" would work properlly */
3299 memcached_server_instance_st instance
=
3300 memcached_server_instance_by_position(memc
, host_index
);
3302 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3304 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3307 memcached_stat_free(NULL
, stat_p
);
3309 return TEST_SUCCESS
;
3311 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3316 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3317 generate_data(memc
);
3319 return TEST_SUCCESS
;
3322 static test_return_t
get_read_count(memcached_st
*memc
)
3324 memcached_return_t rc
;
3325 memcached_st
*memc_clone
;
3327 memc_clone
= memcached_clone(NULL
, memc
);
3328 test_true(memc_clone
);
3330 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3334 size_t return_value_length
;
3338 for (size_t x
= count
= 0; x
< global_count
; x
++)
3340 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3341 &return_value_length
, &flags
, &rc
);
3342 if (rc
== MEMCACHED_SUCCESS
)
3351 memcached_free(memc_clone
);
3353 return TEST_SUCCESS
;
3356 static test_return_t
get_read(memcached_st
*memc
)
3358 memcached_return_t rc
;
3362 size_t return_value_length
;
3365 for (size_t x
= 0; x
< global_count
; x
++)
3367 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3368 &return_value_length
, &flags
, &rc
);
3370 test_true(return_value);
3371 test_true(rc == MEMCACHED_SUCCESS);
3373 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3378 return TEST_SUCCESS
;
3381 static test_return_t
mget_read(memcached_st
*memc
)
3383 memcached_return_t rc
;
3385 if (! libmemcached_util_version_check(memc
, 1, 4, 4))
3386 return TEST_SKIPPED
;
3388 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3390 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
3392 // Go fetch the keys and test to see if all of them were returned
3394 size_t keys_returned
;
3395 test_true(fetch_all_results(memc
, &keys_returned
) == TEST_SUCCESS
);
3397 snprintf(buffer
, sizeof(buffer
), "%lu", (unsigned long)keys_returned
);
3398 test_true_got(global_count
== keys_returned
, buffer
);
3402 return TEST_SUCCESS
;
3405 static test_return_t
mget_read_result(memcached_st
*memc
)
3407 memcached_return_t rc
;
3409 if (! libmemcached_util_version_check(memc
, 1, 4, 4))
3410 return TEST_SKIPPED
;
3412 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3414 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
3416 /* Turn this into a help function */
3418 memcached_result_st results_obj
;
3419 memcached_result_st
*results
;
3421 results
= memcached_result_create(memc
, &results_obj
);
3423 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3426 test_true(rc
== MEMCACHED_SUCCESS
);
3429 memcached_result_free(&results_obj
);
3432 return TEST_SUCCESS
;
3435 static test_return_t
mget_read_function(memcached_st
*memc
)
3437 memcached_return_t rc
;
3439 memcached_execute_fn callbacks
[1];
3441 if (! libmemcached_util_version_check(memc
, 1, 4, 4))
3442 return TEST_SKIPPED
;
3444 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3446 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
3448 callbacks
[0]= &callback_counter
;
3450 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
3452 return TEST_SUCCESS
;
3455 static test_return_t
delete_generate(memcached_st
*memc
)
3457 for (size_t x
= 0; x
< global_count
; x
++)
3459 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3462 return TEST_SUCCESS
;
3465 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3470 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3472 for (size_t x
= 0; x
< global_count
; x
++)
3474 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3477 return TEST_SUCCESS
;
3480 static test_return_t
add_host_test1(memcached_st
*memc
)
3482 memcached_return_t rc
;
3483 char servername
[]= "0.example.com";
3484 memcached_server_st
*servers
;
3486 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3488 test_true(1 == memcached_server_list_count(servers
));
3490 for (size_t x
= 2; x
< 20; x
++)
3492 char buffer
[SMALL_STRING_LEN
];
3494 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3495 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3497 test_true(rc
== MEMCACHED_SUCCESS
);
3498 test_true(x
== memcached_server_list_count(servers
));
3501 rc
= memcached_server_push(memc
, servers
);
3502 test_true(rc
== MEMCACHED_SUCCESS
);
3503 rc
= memcached_server_push(memc
, servers
);
3504 test_true(rc
== MEMCACHED_SUCCESS
);
3506 memcached_server_list_free(servers
);
3508 return TEST_SUCCESS
;
3511 static test_return_t
pre_nonblock(memcached_st
*memc
)
3513 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3515 return TEST_SUCCESS
;
3518 static test_return_t
pre_cork(memcached_st
*memc
)
3520 memcached_return_t rc
;
3523 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
3526 return TEST_SKIPPED
;
3529 if (rc
== MEMCACHED_SUCCESS
)
3530 return TEST_SUCCESS
;
3532 return TEST_SKIPPED
;
3535 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3542 return TEST_SKIPPED
;
3545 if (rc
!= TEST_SUCCESS
)
3548 return pre_nonblock(memc
);
3551 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3553 memcached_return_t rc
= MEMCACHED_FAILURE
;
3554 memcached_st
*memc_clone
;
3556 memc_clone
= memcached_clone(NULL
, memc
);
3557 test_true(memc_clone
);
3558 // The memcached_version needs to be done on a clone, because the server
3559 // will not toggle protocol on an connection.
3560 memcached_version(memc_clone
);
3562 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3564 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3565 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3566 test_true(rc
== MEMCACHED_SUCCESS
);
3567 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3571 return TEST_SKIPPED
;
3574 memcached_free(memc_clone
);
3576 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3579 static test_return_t
pre_murmur(memcached_st
*memc
)
3581 #ifdef HAVE_MURMUR_HASH
3582 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3583 return TEST_SUCCESS
;
3586 return TEST_SKIPPED
;
3590 static test_return_t
pre_jenkins(memcached_st
*memc
)
3592 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3594 return TEST_SUCCESS
;
3598 static test_return_t
pre_md5(memcached_st
*memc
)
3600 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3602 return TEST_SUCCESS
;
3605 static test_return_t
pre_crc(memcached_st
*memc
)
3607 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3609 return TEST_SUCCESS
;
3612 static test_return_t
pre_hsieh(memcached_st
*memc
)
3614 #ifdef HAVE_HSIEH_HASH
3615 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3616 return TEST_SUCCESS
;
3619 return TEST_SKIPPED
;
3623 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3625 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3627 return TEST_SUCCESS
;
3630 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3632 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3634 return TEST_SUCCESS
;
3637 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3639 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3641 return TEST_SUCCESS
;
3644 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3646 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3648 return TEST_SUCCESS
;
3651 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3653 memcached_return_t rc
;
3656 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3657 test_true(rc
== MEMCACHED_SUCCESS
);
3659 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3660 test_true(value
== 1);
3662 return TEST_SUCCESS
;
3665 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3667 memcached_return_t rc
;
3670 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3671 test_true(rc
== MEMCACHED_SUCCESS
);
3673 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3674 test_true(value
== 1);
3676 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3677 test_true(rc
== MEMCACHED_SUCCESS
);
3679 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3680 test_true(value
== MEMCACHED_HASH_MD5
);
3682 return TEST_SUCCESS
;
3686 @note This should be testing to see if the server really supports the binary protocol.
3688 static test_return_t
pre_binary(memcached_st
*memc
)
3690 memcached_return_t rc
= MEMCACHED_FAILURE
;
3692 if (libmemcached_util_version_check(memc
, 1, 4, 4))
3694 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3695 test_true(rc
== MEMCACHED_SUCCESS
);
3696 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3699 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3702 static test_return_t
pre_sasl(memcached_st
*memc
)
3704 memcached_return_t rc
= MEMCACHED_FAILURE
;
3706 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
3707 const char *server
= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
3708 const char *user
= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
3709 const char *pass
= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
3711 if (server
!= NULL
&& user
!= NULL
&& pass
!= NULL
)
3713 memcached_server_st
*servers
= memcached_servers_parse(server
);
3714 test_true(servers
!= NULL
);
3715 memcached_servers_reset(memc
);
3716 test_true(memcached_server_push(memc
, servers
) == MEMCACHED_SUCCESS
);
3717 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3718 rc
= memcached_set_sasl_auth_data(memc
, user
, pass
);
3719 test_true(rc
== MEMCACHED_SUCCESS
);
3725 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3728 static test_return_t
pre_replication(memcached_st
*memc
)
3730 test_return_t test_rc
;
3731 test_rc
= pre_binary(memc
);
3733 if (test_rc
!= TEST_SUCCESS
)
3737 * Make sure that we store the item on all servers
3738 * (master + replicas == number of servers)
3740 memcached_return_t rc
;
3741 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3742 memcached_server_count(memc
) - 1);
3743 test_true(rc
== MEMCACHED_SUCCESS
);
3744 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memcached_server_count(memc
) - 1);
3746 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3750 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3754 rc
= pre_replication(memc
);
3755 if (rc
!= TEST_SUCCESS
)
3758 rc
= pre_nonblock(memc
);
3764 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3768 #ifdef HARD_MALLOC_TESTS
3769 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3777 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3781 #ifdef HARD_MALLOC_TESTS
3782 void *ret
= malloc(size
+ 8);
3785 ret
= (void*)((caddr_t
)ret
+ 8);
3788 void *ret
= malloc(size
);
3793 memset(ret
, 0xff, size
);
3800 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *context
)
3803 #ifdef HARD_MALLOC_TESTS
3804 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3805 void *nmem
= realloc(real_ptr
, size
+ 8);
3810 ret
= (void*)((caddr_t
)nmem
+ 8);
3816 return realloc(mem
, size
);
3821 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *context
)
3824 #ifdef HARD_MALLOC_TESTS
3825 void *mem
= my_malloc(ptr
, nelem
* size
);
3828 memset(mem
, 0, nelem
* size
);
3834 return calloc(nelem
, size
);
3839 static test_return_t
set_prefix(memcached_st
*memc
)
3841 memcached_return_t rc
;
3842 const char *key
= "mine";
3845 /* Make sure be default none exists */
3846 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3847 test_true(rc
== MEMCACHED_FAILURE
);
3849 /* Test a clean set */
3850 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3851 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_last_error_message(memc
));
3853 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3855 test_true(memcmp(value
, key
, 4) == 0);
3856 test_true(rc
== MEMCACHED_SUCCESS
);
3858 /* Test that we can turn it off */
3859 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3860 test_true(rc
== MEMCACHED_SUCCESS
);
3862 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3864 test_true(rc
== MEMCACHED_FAILURE
);
3866 /* Now setup for main test */
3867 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3868 test_true(rc
== MEMCACHED_SUCCESS
);
3870 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3872 test_true(rc
== MEMCACHED_SUCCESS
);
3873 test_true(memcmp(value
, key
, 4) == 0);
3875 /* Set to Zero, and then Set to something too large */
3878 memset(long_key
, 0, 255);
3880 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3881 test_true(rc
== MEMCACHED_SUCCESS
);
3883 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3885 test_true(rc
== MEMCACHED_FAILURE
);
3886 test_true(value
== NULL
);
3888 /* Test a long key for failure */
3889 /* TODO, extend test to determine based on setting, what result should be */
3890 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3891 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3892 //test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3893 test_true(rc
== MEMCACHED_SUCCESS
);
3895 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3896 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3897 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3898 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3900 /* Test for a bad prefix, but with a short key */
3901 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3902 test_true(rc
== MEMCACHED_SUCCESS
);
3904 strncpy(long_key
, "dog cat", sizeof(long_key
));
3905 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3906 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3909 return TEST_SUCCESS
;
3913 #ifdef MEMCACHED_ENABLE_DEPRECATED
3914 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3916 void *test_ptr
= NULL
;
3919 memcached_malloc_fn malloc_cb
=
3920 (memcached_malloc_fn
)my_malloc
;
3921 cb_ptr
= *(void **)&malloc_cb
;
3922 memcached_return_t rc
;
3924 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
3925 test_true(rc
== MEMCACHED_SUCCESS
);
3926 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3927 test_true(rc
== MEMCACHED_SUCCESS
);
3928 test_true(test_ptr
== cb_ptr
);
3932 memcached_realloc_fn realloc_cb
=
3933 (memcached_realloc_fn
)my_realloc
;
3934 cb_ptr
= *(void **)&realloc_cb
;
3935 memcached_return_t rc
;
3937 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
3938 test_true(rc
== MEMCACHED_SUCCESS
);
3939 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3940 test_true(rc
== MEMCACHED_SUCCESS
);
3941 test_true(test_ptr
== cb_ptr
);
3945 memcached_free_fn free_cb
=
3946 (memcached_free_fn
)my_free
;
3947 cb_ptr
= *(void **)&free_cb
;
3948 memcached_return_t rc
;
3950 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
3951 test_true(rc
== MEMCACHED_SUCCESS
);
3952 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3953 test_true(rc
== MEMCACHED_SUCCESS
);
3954 test_true(test_ptr
== cb_ptr
);
3957 return TEST_SUCCESS
;
3962 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3964 memcached_return_t rc
;
3965 rc
= memcached_set_memory_allocators(memc
, NULL
, my_free
,
3966 my_realloc
, my_calloc
, NULL
);
3967 test_true(rc
== MEMCACHED_FAILURE
);
3969 rc
= memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3970 my_realloc
, my_calloc
, NULL
);
3972 memcached_malloc_fn mem_malloc
;
3973 memcached_free_fn mem_free
;
3974 memcached_realloc_fn mem_realloc
;
3975 memcached_calloc_fn mem_calloc
;
3976 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3977 &mem_realloc
, &mem_calloc
);
3979 test_true(mem_malloc
== my_malloc
);
3980 test_true(mem_realloc
== my_realloc
);
3981 test_true(mem_calloc
== my_calloc
);
3982 test_true(mem_free
== my_free
);
3984 return TEST_SUCCESS
;
3987 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3990 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3991 memcached_hash_t hash
;
3992 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3993 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3996 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3997 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3999 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4001 if (hash
!= MEMCACHED_HASH_CRC
)
4002 return TEST_SKIPPED
;
4004 return TEST_SUCCESS
;
4007 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
4010 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4011 memcached_hash_t hash
;
4012 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4013 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
4016 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4017 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4019 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4021 if (hash
!= MEMCACHED_HASH_HSIEH
)
4022 return TEST_SKIPPED
;
4025 return TEST_SUCCESS
;
4028 static test_return_t
enable_cas(memcached_st
*memc
)
4030 unsigned int set
= 1;
4032 if (libmemcached_util_version_check(memc
, 1, 2, 4))
4034 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
4036 return TEST_SUCCESS
;
4039 return TEST_SKIPPED
;
4042 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
4044 memcached_version(memc
);
4046 memcached_server_instance_st instance
=
4047 memcached_server_instance_by_position(memc
, 0);
4049 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
4050 || instance
->minor_version
> 2)
4052 return TEST_SUCCESS
;
4055 return TEST_SKIPPED
;
4058 static test_return_t
pre_unix_socket(memcached_st
*memc
)
4060 memcached_return_t rc
;
4063 memcached_servers_reset(memc
);
4065 if (stat("/tmp/memcached.socket", &buf
))
4066 return TEST_SKIPPED
;
4068 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
4070 return ( rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_FAILURE
);
4073 static test_return_t
pre_nodelay(memcached_st
*memc
)
4075 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
4076 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
4078 return TEST_SUCCESS
;
4081 static test_return_t
pre_settimer(memcached_st
*memc
)
4083 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4084 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4086 return TEST_SUCCESS
;
4089 static test_return_t
poll_timeout(memcached_st
*memc
)
4095 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4097 timeout
= (size_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
4099 test_true(timeout
== 100);
4101 return TEST_SUCCESS
;
4104 static test_return_t
noreply_test(memcached_st
*memc
)
4106 memcached_return_t ret
;
4107 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
4108 test_true(ret
== MEMCACHED_SUCCESS
);
4109 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4110 test_true(ret
== MEMCACHED_SUCCESS
);
4111 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
4112 test_true(ret
== MEMCACHED_SUCCESS
);
4113 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
4114 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
4115 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
4117 for (int count
=0; count
< 5; ++count
)
4119 for (size_t x
= 0; x
< 100; ++x
)
4122 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4123 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4125 size_t len
= (size_t)check_length
;
4130 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4133 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4136 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4139 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4142 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4148 test_true(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
4152 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4153 ** API and is _ONLY_ done this way to verify that the library works the
4154 ** way it is supposed to do!!!!
4157 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4159 memcached_server_instance_st instance
=
4160 memcached_server_instance_by_position(memc
, x
);
4161 no_msg
+=(int)(instance
->cursor_active
);
4164 test_true(no_msg
== 0);
4165 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4168 ** Now validate that all items was set properly!
4170 for (size_t x
= 0; x
< 100; ++x
)
4174 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4176 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4178 size_t len
= (size_t)check_length
;
4181 char* value
=memcached_get(memc
, key
, strlen(key
),
4182 &length
, &flags
, &ret
);
4183 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4186 case 0: /* FALLTHROUGH */
4187 case 1: /* FALLTHROUGH */
4189 test_true(strncmp(value
, key
, len
) == 0);
4190 test_true(len
== length
);
4193 test_true(length
== len
* 2);
4196 test_true(length
== len
* 3);
4206 /* Try setting an illegal cas value (should not return an error to
4207 * the caller (because we don't expect a return message from the server)
4209 const char* keys
[]= {"0"};
4210 size_t lengths
[]= {1};
4213 memcached_result_st results_obj
;
4214 memcached_result_st
*results
;
4215 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4216 test_true(ret
== MEMCACHED_SUCCESS
);
4218 results
= memcached_result_create(memc
, &results_obj
);
4220 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4222 test_true(ret
== MEMCACHED_SUCCESS
);
4223 uint64_t cas
= memcached_result_cas(results
);
4224 memcached_result_free(&results_obj
);
4226 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4227 test_true(ret
== MEMCACHED_SUCCESS
);
4230 * The item will have a new cas value, so try to set it again with the old
4231 * value. This should fail!
4233 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4234 test_true(ret
== MEMCACHED_SUCCESS
);
4235 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4236 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4237 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4240 return TEST_SUCCESS
;
4243 static test_return_t
analyzer_test(memcached_st
*memc
)
4245 memcached_return_t rc
;
4246 memcached_stat_st
*memc_stat
;
4247 memcached_analysis_st
*report
;
4249 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4250 test_true(rc
== MEMCACHED_SUCCESS
);
4251 test_true(memc_stat
);
4253 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4254 test_true(rc
== MEMCACHED_SUCCESS
);
4258 memcached_stat_free(NULL
, memc_stat
);
4260 return TEST_SUCCESS
;
4263 /* Count the objects */
4264 static memcached_return_t
callback_dump_counter(const memcached_st
*ptr
,
4269 (void)ptr
; (void)key
; (void)key_length
;
4270 size_t *counter
= (size_t *)context
;
4272 *counter
= *counter
+ 1;
4274 return MEMCACHED_SUCCESS
;
4277 static test_return_t
dump_test(memcached_st
*memc
)
4279 memcached_return_t rc
;
4281 memcached_dump_fn callbacks
[1];
4282 test_return_t main_rc
;
4284 callbacks
[0]= &callback_dump_counter
;
4286 /* No support for Binary protocol yet */
4287 if (memc
->flags
.binary_protocol
)
4288 return TEST_SUCCESS
;
4290 main_rc
= set_test3(memc
);
4292 test_true (main_rc
== TEST_SUCCESS
);
4294 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
4295 test_true(rc
== MEMCACHED_SUCCESS
);
4297 /* We may have more then 32 if our previous flush has not completed */
4298 test_true(counter
>= 32);
4300 return TEST_SUCCESS
;
4303 #ifdef HAVE_LIBMEMCACHEDUTIL
4304 static void* connection_release(void *arg
)
4307 memcached_pool_st
* pool
;
4312 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
4316 #define POOL_SIZE 10
4317 static test_return_t
connection_pool_test(memcached_st
*memc
)
4319 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4320 test_true(pool
!= NULL
);
4321 memcached_st
*mmc
[POOL_SIZE
];
4322 memcached_return_t rc
;
4324 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4326 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4327 test_true(mmc
[x
] != NULL
);
4328 test_true(rc
== MEMCACHED_SUCCESS
);
4331 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4332 test_true(rc
== MEMCACHED_SUCCESS
);
4336 memcached_pool_st
* pool
;
4338 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
4339 pthread_create(&tid
, NULL
, connection_release
, &item
);
4340 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4341 test_true(rc
== MEMCACHED_SUCCESS
);
4342 pthread_join(tid
, NULL
);
4343 test_true(mmc
[9] == item
.mmc
);
4344 const char *key
= "key";
4345 size_t keylen
= strlen(key
);
4347 // verify that I can do ops with all connections
4348 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
4349 test_true(rc
== MEMCACHED_SUCCESS
);
4351 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4353 uint64_t number_value
;
4354 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
4355 test_true(rc
== MEMCACHED_SUCCESS
);
4356 test_true(number_value
== (x
+1));
4360 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4362 test_true(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
4366 /* verify that I can set behaviors on the pool when I don't have all
4367 * of the connections in the pool. It should however be enabled
4368 * when I push the item into the pool
4370 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4371 test_true(mmc
[0] != NULL
);
4373 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4374 test_true(rc
== MEMCACHED_SUCCESS
);
4376 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4377 test_true(mmc
[1] != NULL
);
4379 test_true(memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4380 test_true(memcached_pool_push(pool
, mmc
[1]) == MEMCACHED_SUCCESS
);
4381 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4383 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4384 test_true(memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4385 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4387 test_true(memcached_pool_destroy(pool
) == memc
);
4389 return TEST_SUCCESS
;
4392 static test_return_t
util_version_test(memcached_st
*memc
)
4396 if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4397 test_true(if_successful
== true);
4399 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4401 // We expect failure
4404 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4405 fprintf(stderr
, "\nDumping Server Information\n\n");
4406 memcached_server_fn callbacks
[1];
4408 callbacks
[0]= dump_server_information
;
4409 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4410 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4412 test_true(if_successful
== false);
4414 memcached_server_instance_st instance
=
4415 memcached_server_instance_by_position(memc
, 0);
4417 memcached_version(memc
);
4419 // We only use one binary when we test, so this should be just fine.
4420 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4421 test_true(if_successful
== true);
4423 if (instance
->micro_version
> 0)
4424 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4425 else if (instance
->minor_version
> 0)
4426 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4427 else if (instance
->major_version
> 0)
4428 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4430 test_true(if_successful
== true);
4432 if (instance
->micro_version
> 0)
4433 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4434 else if (instance
->minor_version
> 0)
4435 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4436 else if (instance
->major_version
> 0)
4437 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4439 test_true(if_successful
== false);
4441 return TEST_SUCCESS
;
4444 static test_return_t
ping_test(memcached_st
*memc
)
4446 memcached_return_t rc
;
4447 memcached_server_instance_st instance
=
4448 memcached_server_instance_by_position(memc
, 0);
4450 // Test both the version that returns a code, and the one that does not.
4451 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4452 memcached_server_port(instance
), NULL
));
4454 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4455 memcached_server_port(instance
), &rc
));
4457 test_true(rc
== MEMCACHED_SUCCESS
);
4459 return TEST_SUCCESS
;
4465 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4469 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4470 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4471 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4472 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4473 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4474 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4475 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4476 #ifdef HAVE_HSIEH_HASH
4477 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4479 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4480 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4481 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4483 return TEST_SUCCESS
;
4487 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4489 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4490 #ifdef HAVE_HSIEH_HASH
4491 expected_rc
= MEMCACHED_SUCCESS
;
4493 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4494 (uint64_t)MEMCACHED_HASH_HSIEH
);
4495 test_true(rc
== expected_rc
);
4497 return TEST_SUCCESS
;
4500 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4502 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4503 #ifdef HAVE_MURMUR_HASH
4504 expected_rc
= MEMCACHED_SUCCESS
;
4506 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4507 (uint64_t)MEMCACHED_HASH_MURMUR
);
4508 test_true(rc
== expected_rc
);
4510 return TEST_SUCCESS
;
4513 static test_return_t
one_at_a_time_run (memcached_st
*memc
)
4519 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4523 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
);
4524 test_true(one_at_a_time_values
[x
] == hash_val
);
4527 return TEST_SUCCESS
;
4530 static test_return_t
md5_run (memcached_st
*memc
)
4536 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4540 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4541 test_true(md5_values
[x
] == hash_val
);
4544 return TEST_SUCCESS
;
4547 static test_return_t
crc_run (memcached_st
*memc
)
4553 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4557 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4558 test_true(crc_values
[x
] == hash_val
);
4561 return TEST_SUCCESS
;
4564 static test_return_t
fnv1_64_run (memcached_st
*memc
)
4570 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4574 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4575 test_true(fnv1_64_values
[x
] == hash_val
);
4578 return TEST_SUCCESS
;
4581 static test_return_t
fnv1a_64_run (memcached_st
*memc
)
4587 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4591 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4592 test_true(fnv1a_64_values
[x
] == hash_val
);
4595 return TEST_SUCCESS
;
4598 static test_return_t
fnv1_32_run (memcached_st
*memc
)
4604 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4608 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4609 test_true(fnv1_32_values
[x
] == hash_val
);
4612 return TEST_SUCCESS
;
4615 static test_return_t
fnv1a_32_run (memcached_st
*memc
)
4621 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4625 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4626 test_true(fnv1a_32_values
[x
] == hash_val
);
4629 return TEST_SUCCESS
;
4632 static test_return_t
hsieh_run (memcached_st
*memc
)
4638 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4642 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4643 test_true(hsieh_values
[x
] == hash_val
);
4646 return TEST_SUCCESS
;
4649 static test_return_t
murmur_run (memcached_st
*memc
)
4651 #ifdef WORDS_BIGENDIAN
4652 (void)murmur_values
;
4653 return TEST_SKIPPED
;
4659 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4663 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
4664 test_true(murmur_values
[x
] == hash_val
);
4667 return TEST_SUCCESS
;
4671 static test_return_t
jenkins_run (memcached_st
*memc
)
4677 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4681 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4682 test_true(jenkins_values
[x
] == hash_val
);
4685 return TEST_SUCCESS
;
4688 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *context
)
4691 return libhashkit_md5(string
, string_length
);
4694 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *context
)
4697 return libhashkit_crc32(string
, string_length
);
4700 static test_return_t
memcached_get_hashkit_test (memcached_st
*memc
)
4704 const hashkit_st
*kit
;
4706 hashkit_return_t hash_rc
;
4708 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};
4709 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};
4711 kit
= memcached_get_hashkit(memc
);
4713 hashkit_clone(&new_kit
, kit
);
4714 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
);
4715 test_true(hash_rc
== HASHKIT_SUCCESS
);
4717 memcached_set_hashkit(memc
, &new_kit
);
4720 Verify Setting the hash.
4722 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4726 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4727 test_true(md5_values
[x
] == hash_val
);
4732 Now check memcached_st.
4734 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4738 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4739 test_true(md5_hosts
[x
] == hash_val
);
4742 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
);
4743 test_true(hash_rc
== HASHKIT_SUCCESS
);
4745 memcached_set_hashkit(memc
, &new_kit
);
4748 Verify Setting the hash.
4750 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4754 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4755 test_true(crc_values
[x
] == hash_val
);
4758 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4762 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4763 test_true(crc_hosts
[x
] == hash_val
);
4766 return TEST_SUCCESS
;
4770 Test case adapted from John Gorman <johngorman2@gmail.com>
4772 We are testing the error condition when we connect to a server via memcached_get()
4773 but find that the server is not available.
4775 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*memc
)
4778 memcached_st
*tl_memc_h
;
4779 memcached_server_st
*servers
;
4781 const char *key
= "MemcachedLives";
4784 memcached_return rc
;
4788 tl_memc_h
= memcached_create(NULL
);
4789 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4790 memcached_server_push(tl_memc_h
, servers
);
4791 memcached_server_list_free(servers
);
4793 // See if memcached is reachable.
4794 value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4797 test_true(len
== 0);
4798 test_false(rc
== MEMCACHED_SUCCESS
);
4800 memcached_free(tl_memc_h
);
4802 return TEST_SUCCESS
;
4806 We connect to a server which exists, but search for a key that does not exist.
4808 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4810 const char *key
= "MemcachedKeyNotEXIST";
4813 memcached_return rc
;
4816 // See if memcached is reachable.
4817 value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4820 test_true(len
== 0);
4821 test_true(rc
== MEMCACHED_NOTFOUND
);
4823 return TEST_SUCCESS
;
4827 Test case adapted from John Gorman <johngorman2@gmail.com>
4829 We are testing the error condition when we connect to a server via memcached_get_by_key()
4830 but find that the server is not available.
4832 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4835 memcached_st
*tl_memc_h
;
4836 memcached_server_st
*servers
;
4838 const char *key
= "MemcachedLives";
4841 memcached_return rc
;
4845 tl_memc_h
= memcached_create(NULL
);
4846 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4847 memcached_server_push(tl_memc_h
, servers
);
4848 memcached_server_list_free(servers
);
4850 // See if memcached is reachable.
4851 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4854 test_true(len
== 0);
4855 test_false(rc
== MEMCACHED_SUCCESS
);
4857 memcached_free(tl_memc_h
);
4859 return TEST_SUCCESS
;
4863 We connect to a server which exists, but search for a key that does not exist.
4865 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4867 const char *key
= "MemcachedKeyNotEXIST";
4870 memcached_return rc
;
4873 // See if memcached is reachable.
4874 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4877 test_true(len
== 0);
4878 test_true(rc
== MEMCACHED_NOTFOUND
);
4880 return TEST_SUCCESS
;
4884 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*trash
)
4886 memcached_return_t rc
;
4889 memcached_server_st
*server_pool
;
4894 memc
= memcached_create(NULL
);
4897 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
4898 test_true(rc
== MEMCACHED_SUCCESS
);
4900 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
4901 test_true(value
== 1);
4903 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
) == MEMCACHED_SUCCESS
);
4904 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
);
4907 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");
4908 memcached_server_push(memc
, server_pool
);
4910 /* verify that the server list was parsed okay. */
4911 test_true(memcached_server_count(memc
) == 8);
4912 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
4913 test_true(server_pool
[0].port
== 11211);
4914 test_true(server_pool
[0].weight
== 600);
4915 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
4916 test_true(server_pool
[2].port
== 11211);
4917 test_true(server_pool
[2].weight
== 200);
4918 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
4919 test_true(server_pool
[7].port
== 11211);
4920 test_true(server_pool
[7].weight
== 100);
4922 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
4923 * us test the boundary wraparound.
4925 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
4927 /* verify the standard ketama set. */
4928 for (x
= 0; x
< 99; x
++)
4930 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
4931 memcached_server_instance_st instance
=
4932 memcached_server_instance_by_position(memc
, server_idx
);
4933 const char *hostname
= memcached_server_name(instance
);
4935 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
4938 memcached_server_list_free(server_pool
);
4939 memcached_free(memc
);
4941 return TEST_SUCCESS
;
4944 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*trash
)
4946 memcached_return_t rc
;
4948 memcached_server_st
*server_pool
;
4953 memc
= memcached_create(NULL
);
4956 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
4957 test_true(rc
== MEMCACHED_SUCCESS
);
4959 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
4960 test_true(value
== 1);
4962 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
4963 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
);
4965 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");
4966 assert(server_pool
);
4967 memcached_server_push(memc
, server_pool
);
4969 /* verify that the server list was parsed okay. */
4970 test_true(memcached_server_count(memc
) == 8);
4971 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
4972 test_true(server_pool
[0].port
== 11211);
4973 test_true(server_pool
[0].weight
== 600);
4974 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
4975 test_true(server_pool
[2].port
== 11211);
4976 test_true(server_pool
[2].weight
== 200);
4977 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
4978 test_true(server_pool
[7].port
== 11211);
4979 test_true(server_pool
[7].weight
== 100);
4981 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
4982 * us test the boundary wraparound.
4984 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
4986 /* verify the standard ketama set. */
4987 for (uint32_t x
= 0; x
< 99; x
++)
4989 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
4991 memcached_server_instance_st instance
=
4992 memcached_server_instance_by_position(memc
, server_idx
);
4994 const char *hostname
= memcached_server_name(instance
);
4996 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
4999 memcached_server_list_free(server_pool
);
5000 memcached_free(memc
);
5002 return TEST_SUCCESS
;
5005 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5007 test_return_t test_rc
;
5008 test_rc
= pre_binary(memc
);
5010 if (test_rc
!= TEST_SUCCESS
)
5013 memcached_return_t ret
;
5014 const char *key
= "regression_bug_434484";
5015 size_t keylen
= strlen(key
);
5017 ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5018 test_true(ret
== MEMCACHED_NOTSTORED
);
5020 size_t size
= 2048 * 1024;
5021 void *data
= calloc(1, size
);
5022 test_true(data
!= NULL
);
5023 ret
= memcached_set(memc
, key
, keylen
, data
, size
, 0, 0);
5024 test_true(ret
== MEMCACHED_E2BIG
);
5027 return TEST_SUCCESS
;
5030 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5032 test_return_t test_rc
;
5033 test_rc
= pre_binary(memc
);
5035 if (test_rc
!= TEST_SUCCESS
)
5038 memcached_return_t rc
;
5040 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5043 * I only want to hit only _one_ server so I know the number of requests I'm
5044 * sending in the pipleine to the server. Let's try to do a multiget of
5045 * 1024 (that should satisfy most users don't you think?). Future versions
5046 * will include a mget_execute function call if you need a higher number.
5048 uint32_t number_of_hosts
= memcached_server_count(memc
);
5049 memc
->number_of_hosts
= 1;
5050 const size_t max_keys
= 1024;
5051 char **keys
= calloc(max_keys
, sizeof(char*));
5052 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5054 for (size_t x
= 0; x
< max_keys
; ++x
)
5058 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5060 test_true(keys
[x
] != NULL
);
5064 * Run two times.. the first time we should have 100% cache miss,
5065 * and the second time we should have 100% cache hits
5067 for (size_t y
= 0; y
< 2; y
++)
5069 rc
= memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
);
5070 test_true(rc
== MEMCACHED_SUCCESS
);
5071 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5075 /* The first iteration should give me a 100% cache miss. verify that*/
5076 char blob
[1024]= { 0 };
5078 test_true(counter
== 0);
5080 for (size_t x
= 0; x
< max_keys
; ++x
)
5082 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5083 blob
, sizeof(blob
), 0, 0);
5084 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5089 /* Verify that we received all of the key/value pairs */
5090 test_true(counter
== max_keys
);
5094 /* Release allocated resources */
5095 for (size_t x
= 0; x
< max_keys
; ++x
)
5102 memc
->number_of_hosts
= number_of_hosts
;
5104 return TEST_SUCCESS
;
5107 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5109 memcached_return_t rc
;
5110 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5111 test_true(rc
== MEMCACHED_SUCCESS
);
5113 return regression_bug_434843(memc
);
5116 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5118 memcached_return_t rc
;
5119 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5120 test_true(rc
== MEMCACHED_SUCCESS
);
5122 char *bytes
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5123 test_true(rc
== MEMCACHED_SUCCESS
);
5124 test_true(bytes
!= NULL
);
5125 char *bytes_read
= memcached_stat_get_value(memc
, memc_stat
,
5127 test_true(rc
== MEMCACHED_SUCCESS
);
5128 test_true(bytes_read
!= NULL
);
5130 char *bytes_written
= memcached_stat_get_value(memc
, memc_stat
,
5131 "bytes_written", &rc
);
5132 test_true(rc
== MEMCACHED_SUCCESS
);
5133 test_true(bytes_written
!= NULL
);
5135 test_true(strcmp(bytes
, bytes_read
) != 0);
5136 test_true(strcmp(bytes
, bytes_written
) != 0);
5138 /* Release allocated resources */
5141 free(bytes_written
);
5142 memcached_stat_free(NULL
, memc_stat
);
5144 return TEST_SUCCESS
;
5148 * The test case isn't obvious so I should probably document why
5149 * it works the way it does. Bug 442914 was caused by a bug
5150 * in the logic in memcached_purge (it did not handle the case
5151 * where the number of bytes sent was equal to the watermark).
5152 * In this test case, create messages so that we hit that case
5153 * and then disable noreply mode and issue a new command to
5154 * verify that it isn't stuck. If we change the format for the
5155 * delete command or the watermarks, we need to update this
5158 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5160 memcached_return_t rc
;
5161 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
5162 test_true(rc
== MEMCACHED_SUCCESS
);
5163 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5165 uint32_t number_of_hosts
= memcached_server_count(memc
);
5166 memc
->number_of_hosts
= 1;
5171 for (uint32_t x
= 0; x
< 250; ++x
)
5173 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5174 rc
= memcached_delete(memc
, k
, len
, 0);
5175 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5178 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5181 rc
= memcached_delete(memc
, k
, len
, 0);
5182 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5184 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0);
5185 test_true(rc
== MEMCACHED_SUCCESS
);
5186 rc
= memcached_delete(memc
, k
, len
, 0);
5187 test_true(rc
== MEMCACHED_NOTFOUND
);
5189 memc
->number_of_hosts
= number_of_hosts
;
5191 return TEST_SUCCESS
;
5194 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5196 memcached_server_instance_st instance_one
;
5197 memcached_server_instance_st instance_two
;
5199 if (memcached_server_count(memc
) < 3 || pre_replication(memc
) != TEST_SUCCESS
)
5200 return TEST_SKIPPED
;
5202 memcached_return_t rc
;
5204 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2);
5205 test_true(rc
== MEMCACHED_SUCCESS
);
5207 const size_t max_keys
= 100;
5208 char **keys
= calloc(max_keys
, sizeof(char*));
5209 size_t *key_length
= calloc(max_keys
, sizeof(size_t));
5211 for (size_t x
= 0; x
< max_keys
; ++x
)
5215 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5217 test_true(keys
[x
] != NULL
);
5218 rc
= memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0);
5219 test_true(rc
== MEMCACHED_SUCCESS
);
5223 ** We are using the quiet commands to store the replicas, so we need
5224 ** to ensure that all of them are processed before we can continue.
5225 ** In the test we go directly from storing the object to trying to
5226 ** receive the object from all of the different servers, so we
5227 ** could end up in a race condition (the memcached server hasn't yet
5228 ** processed the quiet command from the replication set when it process
5229 ** the request from the other client (created by the clone)). As a
5230 ** workaround for that we call memcached_quit to send the quit command
5231 ** to the server and wait for the response ;-) If you use the test code
5232 ** as an example for your own code, please note that you shouldn't need
5235 memcached_quit(memc
);
5237 /* Verify that all messages are stored, and we didn't stuff too much
5240 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5241 test_true(rc
== MEMCACHED_SUCCESS
);
5244 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5245 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5246 /* Verify that we received all of the key/value pairs */
5247 test_true(counter
== max_keys
);
5249 memcached_quit(memc
);
5251 * Don't do the following in your code. I am abusing the internal details
5252 * within the library, and this is not a supported interface.
5253 * This is to verify correct behavior in the library. Fake that two servers
5256 instance_one
= memcached_server_instance_by_position(memc
, 0);
5257 instance_two
= memcached_server_instance_by_position(memc
, 2);
5258 in_port_t port0
= instance_one
->port
;
5259 in_port_t port2
= instance_two
->port
;
5261 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5262 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5264 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5265 test_true(rc
== MEMCACHED_SUCCESS
);
5268 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5269 test_true(counter
== (unsigned int)max_keys
);
5271 /* restore the memc handle */
5272 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5273 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5275 memcached_quit(memc
);
5277 /* Remove half of the objects */
5278 for (size_t x
= 0; x
< max_keys
; ++x
)
5282 rc
= memcached_delete(memc
, keys
[x
], key_length
[x
], 0);
5283 test_true(rc
== MEMCACHED_SUCCESS
);
5287 memcached_quit(memc
);
5288 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5289 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5291 /* now retry the command, this time we should have cache misses */
5292 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5293 test_true(rc
== MEMCACHED_SUCCESS
);
5296 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5297 test_true(counter
== (unsigned int)(max_keys
>> 1));
5299 /* Release allocated resources */
5300 for (size_t x
= 0; x
< max_keys
; ++x
)
5307 /* restore the memc handle */
5308 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5309 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5311 return TEST_SUCCESS
;
5314 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5316 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5317 test_true(memc_clone
!= NULL
);
5318 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5320 memcached_server_instance_st instance
=
5321 memcached_server_instance_by_position(memc_clone
, 0);
5323 if (instance
->major_version
> 1 ||
5324 (instance
->major_version
== 1 &&
5325 instance
->minor_version
> 2))
5327 /* Binary protocol doesn't support deferred delete */
5328 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5329 test_true(bin_clone
!= NULL
);
5330 test_true(memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1) == MEMCACHED_SUCCESS
);
5331 test_true(memcached_delete(bin_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5332 memcached_free(bin_clone
);
5334 memcached_quit(memc_clone
);
5336 /* If we know the server version, deferred delete should fail
5337 * with invalid arguments */
5338 test_true(memcached_delete(memc_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5340 /* If we don't know the server version, we should get a protocol error */
5341 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5343 /* but there is a bug in some of the memcached servers (1.4) that treats
5344 * the counter as noreply so it doesn't send the proper error message
5346 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5348 /* And buffered mode should be disabled and we should get protocol error */
5349 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5350 rc
= memcached_delete(memc
, "foo", 3, 1);
5351 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5353 /* Same goes for noreply... */
5354 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1) == MEMCACHED_SUCCESS
);
5355 rc
= memcached_delete(memc
, "foo", 3, 1);
5356 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5358 /* but a normal request should go through (and be buffered) */
5359 test_true((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_BUFFERED
);
5360 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
5362 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0) == MEMCACHED_SUCCESS
);
5363 /* unbuffered noreply should be success */
5364 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_SUCCESS
);
5365 /* unbuffered with reply should be not found... */
5366 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0) == MEMCACHED_SUCCESS
);
5367 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_NOTFOUND
);
5370 memcached_free(memc_clone
);
5371 return TEST_SUCCESS
;
5375 /* Test memcached_server_get_last_disconnect
5376 * For a working server set, shall be NULL
5377 * For a set of non existing server, shall not be NULL
5379 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5381 memcached_return_t rc
;
5382 memcached_server_instance_st disconnected_server
;
5384 /* With the working set of server */
5385 const char *key
= "marmotte";
5386 const char *value
= "milka";
5388 memcached_reset_last_disconnected_server(memc
);
5389 rc
= memcached_set(memc
, key
, strlen(key
),
5390 value
, strlen(value
),
5391 (time_t)0, (uint32_t)0);
5392 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5394 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5395 test_true(disconnected_server
== NULL
);
5397 /* With a non existing server */
5399 memcached_server_st
*servers
;
5401 const char *server_list
= "localhost:9";
5403 servers
= memcached_servers_parse(server_list
);
5405 mine
= memcached_create(NULL
);
5406 rc
= memcached_server_push(mine
, servers
);
5407 test_true(rc
== MEMCACHED_SUCCESS
);
5408 memcached_server_list_free(servers
);
5411 rc
= memcached_set(mine
, key
, strlen(key
),
5412 value
, strlen(value
),
5413 (time_t)0, (uint32_t)0);
5414 test_true(rc
!= MEMCACHED_SUCCESS
);
5416 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5417 if (disconnected_server
== NULL
)
5419 fprintf(stderr
, "RC %s\n", memcached_strerror(mine
, rc
));
5422 test_true(disconnected_server
!= NULL
);
5423 test_true(memcached_server_port(disconnected_server
)== 9);
5424 test_true(strncmp(memcached_server_name(disconnected_server
),"localhost",9) == 0);
5426 memcached_quit(mine
);
5427 memcached_free(mine
);
5429 return TEST_SUCCESS
;
5432 static test_return_t
test_verbosity(memcached_st
*memc
)
5434 memcached_verbosity(memc
, 3);
5436 return TEST_SUCCESS
;
5439 static test_return_t
test_server_failure(memcached_st
*memc
)
5441 memcached_st
*local_memc
;
5442 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
5444 local_memc
= memcached_create(NULL
);
5446 memcached_server_add(local_memc
, memcached_server_name(instance
), memcached_server_port(instance
));
5447 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 2);
5449 uint32_t server_count
= memcached_server_count(local_memc
);
5451 test_true(server_count
== 1);
5453 // Disable the server
5454 instance
= memcached_server_instance_by_position(local_memc
, 0);
5455 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 2;
5457 memcached_return_t rc
;
5458 rc
= memcached_set(local_memc
, "foo", strlen("foo"),
5460 (time_t)0, (uint32_t)0);
5461 test_true(rc
== MEMCACHED_SERVER_MARKED_DEAD
);
5463 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5464 rc
= memcached_set(local_memc
, "foo", strlen("foo"),
5466 (time_t)0, (uint32_t)0);
5467 test_true(rc
== MEMCACHED_SUCCESS
);
5470 memcached_free(local_memc
);
5472 return TEST_SUCCESS
;
5475 static test_return_t
test_cull_servers(memcached_st
*memc
)
5477 uint32_t count
= memcached_server_count(memc
);
5479 // Do not do this in your code, it is not supported.
5480 memc
->servers
[1].state
.is_dead
= true;
5481 memc
->state
.is_time_for_rebuild
= true;
5483 uint32_t new_count
= memcached_server_count(memc
);
5484 test_true(count
== new_count
);
5487 test_true(count
== new_count
+ 1 );
5490 return TEST_SUCCESS
;
5494 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5495 const char *key
, size_t key_length
,
5496 const char *value
, size_t value_length
,
5506 return MEMCACHED_SUCCESS
;
5509 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5511 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5512 test_true(rc
== MEMCACHED_SUCCESS
);
5514 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5515 test_true(rc
== MEMCACHED_SUCCESS
);
5517 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5518 test_true(rc
== MEMCACHED_SUCCESS
);
5520 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5521 test_true(rc
== MEMCACHED_SUCCESS
);
5523 return TEST_SUCCESS
;
5527 * This test ensures that the failure counter isn't incremented during
5528 * normal termination of the memcached instance.
5530 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5532 memcached_return_t rc
;
5533 memcached_server_instance_st instance
;
5535 /* Set value to force connection to the server */
5536 const char *key
= "marmotte";
5537 const char *value
= "milka";
5540 * Please note that I'm abusing the internal structures in libmemcached
5541 * in a non-portable way and you shouldn't be doing this. I'm only
5542 * doing this in order to verify that the library works the way it should
5544 uint32_t number_of_hosts
= memcached_server_count(memc
);
5545 memc
->number_of_hosts
= 1;
5547 /* Ensure that we are connected to the server by setting a value */
5548 rc
= memcached_set(memc
, key
, strlen(key
),
5549 value
, strlen(value
),
5550 (time_t)0, (uint32_t)0);
5551 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5554 instance
= memcached_server_instance_by_position(memc
, 0);
5555 /* The test is to see that the memcached_quit doesn't increase the
5556 * the server failure conter, so let's ensure that it is zero
5557 * before sending quit
5559 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5561 memcached_quit(memc
);
5563 /* Verify that it memcached_quit didn't increment the failure counter
5564 * Please note that this isn't bullet proof, because an error could
5567 test_true(instance
->server_failure_counter
== 0);
5569 /* restore the instance */
5570 memc
->number_of_hosts
= number_of_hosts
;
5572 return TEST_SUCCESS
;
5576 * This tests ensures expected disconnections (for some behavior changes
5577 * for instance) do not wrongly increase failure counter
5579 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5581 memcached_return rc
;
5583 memcached_st
*memc_clone
;
5584 memc_clone
= memcached_clone(NULL
, memc
);
5585 test_true(memc_clone
);
5587 /* Set value to force connection to the server */
5588 const char *key
= "marmotte";
5589 const char *value
= "milka";
5590 char *string
= NULL
;
5591 size_t string_length
;
5594 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5595 value
, strlen(value
),
5596 (time_t)0, (uint32_t)0);
5597 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5600 /* put failure limit to 1 */
5601 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5602 assert(rc
== MEMCACHED_SUCCESS
);
5604 /* Put a retry timeout to effectively activate failure_limit effect */
5605 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1);
5606 assert(rc
== MEMCACHED_SUCCESS
);
5608 /* change behavior that triggers memcached_quit()*/
5609 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5610 assert(rc
== MEMCACHED_SUCCESS
);
5613 /* Check if we still are connected */
5614 string
= memcached_get(memc_clone
, key
, strlen(key
),
5615 &string_length
, &flags
, &rc
);
5617 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
5620 memcached_free(memc_clone
);
5622 return TEST_SUCCESS
;
5629 * Test that ensures mget_execute does not end into recursive calls that finally fails
5631 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5633 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5634 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5635 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5636 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5637 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5640 return TEST_SKIPPED
; // My MAC can't handle this test
5644 * I only want to hit _one_ server so I know the number of requests I'm
5645 * sending in the pipeline.
5647 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5648 memc
->number_of_hosts
= 1;
5649 size_t max_keys
= 20480;
5652 char **keys
= calloc(max_keys
, sizeof(char*));
5653 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5655 /* First add all of the items.. */
5657 char blob
[1024]= { 0 };
5658 memcached_return rc
;
5659 for (size_t x
= 0; x
< max_keys
; ++x
)
5662 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5664 assert(keys
[x
] != NULL
);
5665 rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5667 if (rc
== MEMCACHED_SERVER_MARKED_DEAD
)
5669 break; // We are out of business
5672 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
); // MEMCACHED_TIMEOUT <-- only observed on OSX
5674 if (rc
== MEMCACHED_TIMEOUT
&& slept
== false)
5677 sleep(1);// We will try to sleep
5680 else if (rc
== MEMCACHED_TIMEOUT
&& slept
== true)
5682 // We failed to send everything.
5687 if (rc
!= MEMCACHED_SERVER_MARKED_DEAD
)
5690 /* Try to get all of them with a large multiget */
5692 memcached_execute_function callbacks
[1]= { [0]= &callback_counter
};
5693 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5694 (size_t)max_keys
, callbacks
, &counter
, 1);
5696 assert(rc
== MEMCACHED_SUCCESS
);
5697 char* the_value
= NULL
;
5698 char the_key
[MEMCACHED_MAX_KEY
];
5699 size_t the_key_length
;
5700 size_t the_value_length
;
5704 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5706 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5712 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5715 assert(rc
== MEMCACHED_END
);
5717 /* Verify that we got all of the items */
5718 assert(counter
== max_keys
);
5721 /* Release all allocated resources */
5722 for (size_t x
= 0; x
< max_keys
; ++x
)
5729 memc
->number_of_hosts
= number_of_hosts
;
5731 return TEST_SUCCESS
;
5734 static test_return_t
regression_bug_583031(memcached_st
*unused
)
5738 memcached_st
*memc
= memcached_create(NULL
);
5740 memcached_server_add(memc
, "10.2.3.4", 11211);
5742 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5743 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5744 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5745 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5746 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5747 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5749 memcached_return_t rc
;
5753 (void)memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5755 test_true_got(rc
== MEMCACHED_TIMEOUT
, memcached_strerror(NULL
, rc
));
5757 memcached_free(memc
);
5759 return TEST_SUCCESS
;
5762 // Look for memory leak
5763 static test_return_t
regression_bug_728286(memcached_st
*unused
)
5766 memcached_server_st
*servers
= memcached_servers_parse("1.2.3.4:99");
5768 memcached_server_free(servers
);
5770 return TEST_SUCCESS
;
5773 static test_return_t
regression_bug_581030(memcached_st
*unused
)
5778 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5779 test_false(local_stat
);
5781 memcached_stat_free(NULL
, NULL
);
5784 return TEST_SUCCESS
;
5787 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5789 fprintf(stderr
, "Iteration #%u: ", it
);
5791 if(error
== MEMCACHED_ERRNO
)
5793 fprintf(stderr
, "system error %d from %s: %s\n",
5794 errno
, what
, strerror(errno
));
5798 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5799 memcached_strerror(mc
, error
));
5803 #define TEST_CONSTANT_CREATION 200
5805 static test_return_t
regression_bug_(memcached_st
*memc
)
5807 const char *remote_server
;
5810 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5812 return TEST_SKIPPED
;
5815 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5817 memcached_st
* mc
= memcached_create(NULL
);
5818 memcached_return rc
;
5820 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5821 if (rc
!= MEMCACHED_SUCCESS
)
5823 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5826 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5827 if (rc
!= MEMCACHED_SUCCESS
)
5829 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5832 rc
= memcached_server_add(mc
, remote_server
, 0);
5833 if (rc
!= MEMCACHED_SUCCESS
)
5835 memcached_die(mc
, rc
, "memcached_server_add", x
);
5838 const char *set_key
= "akey";
5839 const size_t set_key_len
= strlen(set_key
);
5840 const char *set_value
= "a value";
5841 const size_t set_value_len
= strlen(set_value
);
5843 if (rc
== MEMCACHED_SUCCESS
)
5847 size_t get_value_len
;
5849 uint32_t get_value_flags
;
5851 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5852 &get_value_flags
, &rc
);
5853 if (rc
!= MEMCACHED_SUCCESS
)
5855 memcached_die(mc
, rc
, "memcached_get", x
);
5861 (get_value_len
!= set_value_len
5862 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5864 fprintf(stderr
, "Values don't match?\n");
5865 rc
= MEMCACHED_FAILURE
;
5871 rc
= memcached_set(mc
,
5872 set_key
, set_key_len
,
5873 set_value
, set_value_len
,
5877 if (rc
!= MEMCACHED_SUCCESS
)
5879 memcached_die(mc
, rc
, "memcached_set", x
);
5886 if (rc
!= MEMCACHED_SUCCESS
)
5892 return TEST_SUCCESS
;
5896 * Test that the sasl authentication works. We cannot use the default
5897 * pool of servers, because that would require that all servers we want
5898 * to test supports SASL authentication, and that they use the default
5901 static test_return_t
sasl_auth_test(memcached_st
*memc
)
5903 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
5904 memcached_return_t rc
;
5906 rc
= memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
5907 test_true(rc
== MEMCACHED_SUCCESS
);
5908 test_true((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_SUCCESS
);
5909 test_true((rc
= memcached_destroy_sasl_auth_data(memc
)) == MEMCACHED_SUCCESS
);
5910 test_true((rc
= memcached_destroy_sasl_auth_data(memc
)) == MEMCACHED_FAILURE
);
5911 test_true((rc
= memcached_destroy_sasl_auth_data(NULL
)) == MEMCACHED_FAILURE
);
5912 memcached_quit(memc
);
5914 rc
= memcached_set_sasl_auth_data(memc
,
5915 getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
5916 getenv("LIBMEMCACHED_TEST_SASL_SERVER"));
5917 test_true(rc
== MEMCACHED_SUCCESS
);
5919 rc
= memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
5920 test_true(rc
== MEMCACHED_AUTH_FAILURE
);
5921 test_true(memcached_destroy_sasl_auth_data(memc
) == MEMCACHED_SUCCESS
);
5923 memcached_quit(memc
);
5924 return TEST_SUCCESS
;
5927 return TEST_FAILURE
;
5931 /* Clean the server before beginning testing */
5933 {"util_version", 1, (test_callback_fn
)util_version_test
},
5934 {"flush", 0, (test_callback_fn
)flush_test
},
5935 {"init", 0, (test_callback_fn
)init_test
},
5936 {"allocation", 0, (test_callback_fn
)allocation_test
},
5937 {"server_list_null_test", 0, (test_callback_fn
)server_list_null_test
},
5938 {"server_unsort", 0, (test_callback_fn
)server_unsort_test
},
5939 {"server_sort", 0, (test_callback_fn
)server_sort_test
},
5940 {"server_sort2", 0, (test_callback_fn
)server_sort2_test
},
5941 {"memcached_server_remove", 0, (test_callback_fn
)memcached_server_remove_test
},
5942 {"clone_test", 0, (test_callback_fn
)clone_test
},
5943 {"connection_test", 0, (test_callback_fn
)connection_test
},
5944 {"callback_test", 0, (test_callback_fn
)callback_test
},
5945 {"userdata_test", 0, (test_callback_fn
)userdata_test
},
5946 {"error", 0, (test_callback_fn
)error_test
},
5947 {"set", 0, (test_callback_fn
)set_test
},
5948 {"set2", 0, (test_callback_fn
)set_test2
},
5949 {"set3", 0, (test_callback_fn
)set_test3
},
5950 {"dump", 1, (test_callback_fn
)dump_test
},
5951 {"add", 1, (test_callback_fn
)add_test
},
5952 {"replace", 1, (test_callback_fn
)replace_test
},
5953 {"delete", 1, (test_callback_fn
)delete_test
},
5954 {"get", 1, (test_callback_fn
)get_test
},
5955 {"get2", 0, (test_callback_fn
)get_test2
},
5956 {"get3", 0, (test_callback_fn
)get_test3
},
5957 {"get4", 0, (test_callback_fn
)get_test4
},
5958 {"partial mget", 0, (test_callback_fn
)get_test5
},
5959 {"stats_servername", 0, (test_callback_fn
)stats_servername_test
},
5960 {"increment", 0, (test_callback_fn
)increment_test
},
5961 {"increment_with_initial", 1, (test_callback_fn
)increment_with_initial_test
},
5962 {"decrement", 0, (test_callback_fn
)decrement_test
},
5963 {"decrement_with_initial", 1, (test_callback_fn
)decrement_with_initial_test
},
5964 {"increment_by_key", 0, (test_callback_fn
)increment_by_key_test
},
5965 {"increment_with_initial_by_key", 1, (test_callback_fn
)increment_with_initial_by_key_test
},
5966 {"decrement_by_key", 0, (test_callback_fn
)decrement_by_key_test
},
5967 {"decrement_with_initial_by_key", 1, (test_callback_fn
)decrement_with_initial_by_key_test
},
5968 {"quit", 0, (test_callback_fn
)quit_test
},
5969 {"mget", 1, (test_callback_fn
)mget_test
},
5970 {"mget_result", 1, (test_callback_fn
)mget_result_test
},
5971 {"mget_result_alloc", 1, (test_callback_fn
)mget_result_alloc_test
},
5972 {"mget_result_function", 1, (test_callback_fn
)mget_result_function
},
5973 {"mget_execute", 1, (test_callback_fn
)mget_execute
},
5974 {"mget_end", 0, (test_callback_fn
)mget_end
},
5975 {"get_stats", 0, (test_callback_fn
)get_stats
},
5976 {"add_host_test", 0, (test_callback_fn
)add_host_test
},
5977 {"add_host_test_1", 0, (test_callback_fn
)add_host_test1
},
5978 {"get_stats_keys", 0, (test_callback_fn
)get_stats_keys
},
5979 {"version_string_test", 0, (test_callback_fn
)version_string_test
},
5980 {"bad_key", 1, (test_callback_fn
)bad_key_test
},
5981 {"memcached_server_cursor", 1, (test_callback_fn
)memcached_server_cursor_test
},
5982 {"read_through", 1, (test_callback_fn
)read_through
},
5983 {"delete_through", 1, (test_callback_fn
)delete_through
},
5984 {"noreply", 1, (test_callback_fn
)noreply_test
},
5985 {"analyzer", 1, (test_callback_fn
)analyzer_test
},
5986 #ifdef HAVE_LIBMEMCACHEDUTIL
5987 {"connectionpool", 1, (test_callback_fn
)connection_pool_test
},
5988 {"ping", 1, (test_callback_fn
)ping_test
},
5990 {"test_get_last_disconnect", 1, (test_callback_fn
)test_get_last_disconnect
},
5991 {"verbosity", 1, (test_callback_fn
)test_verbosity
},
5992 {"test_server_failure", 1, (test_callback_fn
)test_server_failure
},
5993 {"cull_servers", 1, (test_callback_fn
)test_cull_servers
},
5994 {"memcached_stat_execute", 1, (test_callback_fn
)memcached_stat_execute_test
},
5998 test_st behavior_tests
[] ={
5999 {"behavior_test", 0, (test_callback_fn
)behavior_test
},
6000 {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_CORK_test
},
6001 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
6002 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
6006 test_st basic_tests
[] ={
6007 {"init", 1, (test_callback_fn
)basic_init_test
},
6008 {"clone", 1, (test_callback_fn
)basic_clone_test
},
6009 {"reset", 1, (test_callback_fn
)basic_reset_stack_test
},
6010 {"reset heap", 1, (test_callback_fn
)basic_reset_heap_test
},
6011 {"reset stack clone", 1, (test_callback_fn
)basic_reset_stack_clone_test
},
6012 {"reset heap clone", 1, (test_callback_fn
)basic_reset_heap_clone_test
},
6016 test_st regression_binary_vs_block
[] ={
6017 {"block add", 1, (test_callback_fn
)block_add_regression
},
6018 {"binary add", 1, (test_callback_fn
)binary_add_regression
},
6022 test_st async_tests
[] ={
6023 {"add", 1, (test_callback_fn
)add_wrapper
},
6027 test_st string_tests
[] ={
6028 {"string static with null", 0, (test_callback_fn
)string_static_null
},
6029 {"string alloc with null", 0, (test_callback_fn
)string_alloc_null
},
6030 {"string alloc with 1K", 0, (test_callback_fn
)string_alloc_with_size
},
6031 {"string alloc with malloc failure", 0, (test_callback_fn
)string_alloc_with_size_toobig
},
6032 {"string append", 0, (test_callback_fn
)string_alloc_append
},
6033 {"string append failure (too big)", 0, (test_callback_fn
)string_alloc_append_toobig
},
6034 {"string_alloc_append_multiple", 0, (test_callback_fn
)string_alloc_append_multiple
},
6035 {0, 0, (test_callback_fn
)0}
6038 test_st result_tests
[] ={
6039 {"result static", 0, (test_callback_fn
)result_static
},
6040 {"result alloc", 0, (test_callback_fn
)result_alloc
},
6041 {0, 0, (test_callback_fn
)0}
6044 test_st version_1_2_3
[] ={
6045 {"append", 0, (test_callback_fn
)append_test
},
6046 {"prepend", 0, (test_callback_fn
)prepend_test
},
6047 {"cas", 0, (test_callback_fn
)cas_test
},
6048 {"cas2", 0, (test_callback_fn
)cas2_test
},
6049 {"append_binary", 0, (test_callback_fn
)append_binary_test
},
6050 {0, 0, (test_callback_fn
)0}
6053 test_st user_tests
[] ={
6054 {"user_supplied_bug1", 0, (test_callback_fn
)user_supplied_bug1
},
6055 {"user_supplied_bug2", 0, (test_callback_fn
)user_supplied_bug2
},
6056 {"user_supplied_bug3", 0, (test_callback_fn
)user_supplied_bug3
},
6057 {"user_supplied_bug4", 0, (test_callback_fn
)user_supplied_bug4
},
6058 {"user_supplied_bug5", 1, (test_callback_fn
)user_supplied_bug5
},
6059 {"user_supplied_bug6", 1, (test_callback_fn
)user_supplied_bug6
},
6060 {"user_supplied_bug7", 1, (test_callback_fn
)user_supplied_bug7
},
6061 {"user_supplied_bug8", 1, (test_callback_fn
)user_supplied_bug8
},
6062 {"user_supplied_bug9", 1, (test_callback_fn
)user_supplied_bug9
},
6063 {"user_supplied_bug10", 1, (test_callback_fn
)user_supplied_bug10
},
6064 {"user_supplied_bug11", 1, (test_callback_fn
)user_supplied_bug11
},
6065 {"user_supplied_bug12", 1, (test_callback_fn
)user_supplied_bug12
},
6066 {"user_supplied_bug13", 1, (test_callback_fn
)user_supplied_bug13
},
6067 {"user_supplied_bug14", 1, (test_callback_fn
)user_supplied_bug14
},
6068 {"user_supplied_bug15", 1, (test_callback_fn
)user_supplied_bug15
},
6069 {"user_supplied_bug16", 1, (test_callback_fn
)user_supplied_bug16
},
6070 #if !defined(__sun) && !defined(__OpenBSD__)
6072 ** It seems to be something weird with the character sets..
6073 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6074 ** guess I need to find out how this is supposed to work.. Perhaps I need
6075 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6076 ** so just disable the code for now...).
6078 {"user_supplied_bug17", 1, (test_callback_fn
)user_supplied_bug17
},
6080 {"user_supplied_bug18", 1, (test_callback_fn
)user_supplied_bug18
},
6081 {"user_supplied_bug19", 1, (test_callback_fn
)user_supplied_bug19
},
6082 {"user_supplied_bug20", 1, (test_callback_fn
)user_supplied_bug20
},
6083 {"user_supplied_bug21", 1, (test_callback_fn
)user_supplied_bug21
},
6084 {"wrong_failure_counter_test", 1, (test_callback_fn
)wrong_failure_counter_test
},
6085 {"wrong_failure_counter_two_test", 1, (test_callback_fn
)wrong_failure_counter_two_test
},
6086 {0, 0, (test_callback_fn
)0}
6089 test_st replication_tests
[]= {
6090 {"set", 1, (test_callback_fn
)replication_set_test
},
6091 {"get", 0, (test_callback_fn
)replication_get_test
},
6092 {"mget", 0, (test_callback_fn
)replication_mget_test
},
6093 {"delete", 0, (test_callback_fn
)replication_delete_test
},
6094 {"rand_mget", 0, (test_callback_fn
)replication_randomize_mget_test
},
6095 {0, 0, (test_callback_fn
)0}
6099 * The following test suite is used to verify that we don't introduce
6100 * regression bugs. If you want more information about the bug / test,
6101 * you should look in the bug report at
6102 * http://bugs.launchpad.net/libmemcached
6104 test_st regression_tests
[]= {
6105 {"lp:434484", 1, (test_callback_fn
)regression_bug_434484
},
6106 {"lp:434843", 1, (test_callback_fn
)regression_bug_434843
},
6107 {"lp:434843-buffered", 1, (test_callback_fn
)regression_bug_434843_buffered
},
6108 {"lp:421108", 1, (test_callback_fn
)regression_bug_421108
},
6109 {"lp:442914", 1, (test_callback_fn
)regression_bug_442914
},
6110 {"lp:447342", 1, (test_callback_fn
)regression_bug_447342
},
6111 {"lp:463297", 1, (test_callback_fn
)regression_bug_463297
},
6112 {"lp:490486", 1, (test_callback_fn
)regression_bug_490486
},
6113 {"lp:583031", 1, (test_callback_fn
)regression_bug_583031
},
6114 {"lp:?", 1, (test_callback_fn
)regression_bug_
},
6115 {"lp:728286", 1, (test_callback_fn
)regression_bug_728286
},
6116 {"lp:581030", 1, (test_callback_fn
)regression_bug_581030
},
6117 {0, 0, (test_callback_fn
)0}
6120 test_st sasl_auth_tests
[]= {
6121 {"sasl_auth", 1, (test_callback_fn
)sasl_auth_test
},
6122 {0, 0, (test_callback_fn
)0}
6125 test_st ketama_compatibility
[]= {
6126 {"libmemcached", 1, (test_callback_fn
)ketama_compatibility_libmemcached
},
6127 {"spymemcached", 1, (test_callback_fn
)ketama_compatibility_spymemcached
},
6128 {0, 0, (test_callback_fn
)0}
6131 test_st generate_tests
[] ={
6132 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6133 {"generate_data", 1, (test_callback_fn
)generate_data
},
6134 {"get_read", 0, (test_callback_fn
)get_read
},
6135 {"delete_generate", 0, (test_callback_fn
)delete_generate
},
6136 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
6137 {"delete_buffer", 0, (test_callback_fn
)delete_buffer_generate
},
6138 {"generate_data", 1, (test_callback_fn
)generate_data
},
6139 {"mget_read", 0, (test_callback_fn
)mget_read
},
6140 {"mget_read_result", 0, (test_callback_fn
)mget_read_result
},
6141 {"mget_read_function", 0, (test_callback_fn
)mget_read_function
},
6142 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6143 {"generate_large_pairs", 1, (test_callback_fn
)generate_large_pairs
},
6144 {"generate_data", 1, (test_callback_fn
)generate_data
},
6145 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
6146 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6147 {0, 0, (test_callback_fn
)0}
6150 test_st consistent_tests
[] ={
6151 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6152 {"generate_data", 1, (test_callback_fn
)generate_data
},
6153 {"get_read", 0, (test_callback_fn
)get_read_count
},
6154 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6155 {0, 0, (test_callback_fn
)0}
6158 test_st consistent_weighted_tests
[] ={
6159 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6160 {"generate_data", 1, (test_callback_fn
)generate_data_with_stats
},
6161 {"get_read", 0, (test_callback_fn
)get_read_count
},
6162 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6163 {0, 0, (test_callback_fn
)0}
6166 test_st hsieh_availability
[] ={
6167 {"hsieh_avaibility_test", 0, (test_callback_fn
)hsieh_avaibility_test
},
6168 {0, 0, (test_callback_fn
)0}
6171 test_st murmur_availability
[] ={
6172 {"murmur_avaibility_test", 0, (test_callback_fn
)murmur_avaibility_test
},
6173 {0, 0, (test_callback_fn
)0}
6177 test_st hash_sanity
[] ={
6178 {"hash sanity", 0, (test_callback_fn
)hash_sanity_test
},
6179 {0, 0, (test_callback_fn
)0}
6183 test_st ketama_auto_eject_hosts
[] ={
6184 {"auto_eject_hosts", 1, (test_callback_fn
)auto_eject_hosts
},
6185 {"output_ketama_weighted_keys", 1, (test_callback_fn
)output_ketama_weighted_keys
},
6186 {0, 0, (test_callback_fn
)0}
6189 test_st hash_tests
[] ={
6190 {"one_at_a_time_run", 0, (test_callback_fn
)one_at_a_time_run
},
6191 {"md5", 0, (test_callback_fn
)md5_run
},
6192 {"crc", 0, (test_callback_fn
)crc_run
},
6193 {"fnv1_64", 0, (test_callback_fn
)fnv1_64_run
},
6194 {"fnv1a_64", 0, (test_callback_fn
)fnv1a_64_run
},
6195 {"fnv1_32", 0, (test_callback_fn
)fnv1_32_run
},
6196 {"fnv1a_32", 0, (test_callback_fn
)fnv1a_32_run
},
6197 {"hsieh", 0, (test_callback_fn
)hsieh_run
},
6198 {"murmur", 0, (test_callback_fn
)murmur_run
},
6199 {"jenkis", 0, (test_callback_fn
)jenkins_run
},
6200 {"memcached_get_hashkit", 0, (test_callback_fn
)memcached_get_hashkit_test
},
6201 {0, 0, (test_callback_fn
)0}
6204 test_st error_conditions
[] ={
6205 {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn
)memcached_get_MEMCACHED_ERRNO
},
6206 {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
)memcached_get_MEMCACHED_NOTFOUND
},
6207 {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn
)memcached_get_by_key_MEMCACHED_ERRNO
},
6208 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6209 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6210 {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn
)memcached_increment_MEMCACHED_NO_SERVERS
},
6211 {0, 0, (test_callback_fn
)0}
6215 test_st parser_tests
[] ={
6216 {"behavior", 0, (test_callback_fn
)behavior_parser_test
},
6217 {"boolean_options", 0, (test_callback_fn
)parser_boolean_options_test
},
6218 {"configure_file", 0, (test_callback_fn
)memcached_create_with_options_with_filename
},
6219 {"distribtions", 0, (test_callback_fn
)parser_distribution_test
},
6220 {"hash", 0, (test_callback_fn
)parser_hash_test
},
6221 {"libmemcached_check_configuration", 0, (test_callback_fn
)libmemcached_check_configuration_test
},
6222 {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn
)libmemcached_check_configuration_with_filename_test
},
6223 {"memcached_parse_configure_file", 0, (test_callback_fn
)memcached_parse_configure_file_test
},
6224 {"number_options", 0, (test_callback_fn
)parser_number_options_test
},
6225 {"randomly generated options", 0, (test_callback_fn
)random_statement_build_test
},
6226 {"prefix_key", 0, (test_callback_fn
)parser_key_prefix_test
},
6227 {"server", 0, (test_callback_fn
)server_test
},
6228 {"servers", 0, (test_callback_fn
)servers_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 #define SERVERS_TO_CREATE 5
6307 #include "libmemcached_world.h"
6309 void get_world(world_st
*world
)
6311 world
->collections
= collection
;
6313 world
->create
= (test_callback_create_fn
)world_create
;
6314 world
->destroy
= (test_callback_fn
)world_destroy
;
6316 world
->test
.startup
= (test_callback_fn
)world_test_startup
;
6317 world
->test
.flush
= (test_callback_fn
)world_flush
;
6318 world
->test
.pre_run
= (test_callback_fn
)world_pre_run
;
6319 world
->test
.post_run
= (test_callback_fn
)world_post_run
;
6320 world
->test
.on_error
= (test_callback_error_fn
)world_on_error
;
6322 world
->collection
.startup
= (test_callback_fn
)world_container_startup
;
6323 world
->collection
.shutdown
= (test_callback_fn
)world_container_shutdown
;
6325 world
->runner
= &defualt_libmemcached_runner
;