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"
30 #include "clients/generator.h"
31 #include "clients/execute.h"
33 #define SMALL_STRING_LEN 1024
38 #ifdef HAVE_LIBMEMCACHEDUTIL
40 #include "libmemcached/memcached_util.h"
43 #include "hash_results.h"
45 #define GLOBAL_COUNT 10000
46 #define GLOBAL2_COUNT 100
47 #define SERVERS_TO_CREATE 5
48 static uint32_t global_count
;
50 static pairs_st
*global_pairs
;
51 static const char *global_keys
[GLOBAL_COUNT
];
52 static size_t global_keys_length
[GLOBAL_COUNT
];
55 static test_return_t
pre_binary(memcached_st
*memc
);
58 static test_return_t
init_test(memcached_st
*not_used
__attribute__((unused
)))
62 (void)memcached_create(&memc
);
63 memcached_free(&memc
);
68 static test_return_t
server_list_null_test(memcached_st
*ptr
__attribute__((unused
)))
70 memcached_server_st
*server_list
;
71 memcached_return_t rc
;
73 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, NULL
);
74 test_true(server_list
== NULL
);
76 server_list
= memcached_server_list_append_with_weight(NULL
, "localhost", 0, 0, NULL
);
77 test_true(server_list
== NULL
);
79 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, &rc
);
80 test_true(server_list
== NULL
);
85 #define TEST_PORT_COUNT 7
86 in_port_t test_ports
[TEST_PORT_COUNT
];
88 static memcached_return_t
server_display_function(const memcached_st
*ptr
__attribute__((unused
)),
89 const memcached_server_st
*server
,
93 size_t bigger
= *((size_t *)(context
));
94 assert(bigger
<= memcached_server_port(server
));
95 *((size_t *)(context
))= memcached_server_port(server
);
97 return MEMCACHED_SUCCESS
;
100 static memcached_return_t
dump_server_information(const memcached_st
*ptr
__attribute__((unused
)),
101 const memcached_server_st
*instance
,
105 FILE *stream
= (FILE *)context
;
107 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
108 memcached_server_name(instance
),
109 memcached_server_port(instance
),
110 instance
->major_version
,
111 instance
->minor_version
,
112 instance
->micro_version
);
114 return MEMCACHED_SUCCESS
;
117 static test_return_t
server_sort_test(memcached_st
*ptr
__attribute__((unused
)))
119 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
121 memcached_return_t rc
;
122 memcached_server_fn callbacks
[1];
123 memcached_st
*local_memc
;
125 local_memc
= memcached_create(NULL
);
126 test_true(local_memc
);
127 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
129 for (size_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
131 test_ports
[x
]= (in_port_t
)random() % 64000;
132 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
133 test_true(memcached_server_count(local_memc
) == x
+ 1);
135 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
137 test_true(rc
== MEMCACHED_SUCCESS
);
140 callbacks
[0]= server_display_function
;
141 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
144 memcached_free(local_memc
);
149 static test_return_t
server_sort2_test(memcached_st
*ptr
__attribute__((unused
)))
151 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
152 memcached_return_t rc
;
153 memcached_server_fn callbacks
[1];
154 memcached_st
*local_memc
;
155 memcached_server_instance_st instance
;
157 local_memc
= memcached_create(NULL
);
158 test_true(local_memc
);
159 rc
= memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
160 test_true(rc
== MEMCACHED_SUCCESS
);
162 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
163 test_true(rc
== MEMCACHED_SUCCESS
);
164 instance
= memcached_server_instance_by_position(local_memc
, 0);
165 test_true(memcached_server_port(instance
) == 43043);
167 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
168 test_true(rc
== MEMCACHED_SUCCESS
);
170 instance
= memcached_server_instance_by_position(local_memc
, 0);
171 test_true(memcached_server_port(instance
) == 43042);
173 instance
= memcached_server_instance_by_position(local_memc
, 1);
174 test_true(memcached_server_port(instance
) == 43043);
176 callbacks
[0]= server_display_function
;
177 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
180 memcached_free(local_memc
);
185 static memcached_return_t
server_print_callback(const memcached_st
*ptr
__attribute__((unused
)),
186 const memcached_server_st
*server
,
187 void *context
__attribute__((unused
)))
189 (void)server
; // Just in case we aren't printing.
192 fprintf(stderr
, "%s(%d)", memcached_server_name(server
), memcached_server_port(server
));
195 return MEMCACHED_SUCCESS
;
198 static test_return_t
memcached_server_remove_test(memcached_st
*ptr
__attribute__((unused
)))
200 memcached_return_t rc
;
201 memcached_st local_memc
;
203 memcached_server_st
*servers
;
204 memcached_server_fn callbacks
[1];
206 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";
208 memc
= memcached_create(&local_memc
);
210 servers
= memcached_servers_parse(server_string
);
212 rc
= memcached_server_push(memc
, servers
);
213 memcached_server_list_free(servers
);
215 callbacks
[0]= server_print_callback
;
216 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
218 memcached_free(memc
);
223 static memcached_return_t
server_display_unsort_function(const memcached_st
*ptr
__attribute__((unused
)),
224 const memcached_server_st
*server
,
228 uint32_t x
= *((uint32_t *)(context
));
230 assert(test_ports
[x
] == server
->port
);
231 *((uint32_t *)(context
))= ++x
;
233 return MEMCACHED_SUCCESS
;
236 static test_return_t
server_unsort_test(memcached_st
*ptr
__attribute__((unused
)))
238 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
239 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
240 memcached_return_t rc
;
241 memcached_server_fn callbacks
[1];
242 memcached_st
*local_memc
;
244 local_memc
= memcached_create(NULL
);
245 test_true(local_memc
);
247 for (size_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
249 test_ports
[x
]= (in_port_t
)(random() % 64000);
250 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
251 test_true(memcached_server_count(local_memc
) == x
+1);
253 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
255 test_true(rc
== MEMCACHED_SUCCESS
);
258 callbacks
[0]= server_display_unsort_function
;
259 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
261 /* Now we sort old data! */
262 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
263 callbacks
[0]= server_display_function
;
264 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
267 memcached_free(local_memc
);
272 static test_return_t
allocation_test(memcached_st
*not_used
__attribute__((unused
)))
275 memc
= memcached_create(NULL
);
277 memcached_free(memc
);
282 static test_return_t
clone_test(memcached_st
*memc
)
286 memcached_st
*memc_clone
;
287 memc_clone
= memcached_clone(NULL
, NULL
);
288 test_true(memc_clone
);
289 memcached_free(memc_clone
);
292 /* Can we init from null? */
294 memcached_st
*memc_clone
;
295 memc_clone
= memcached_clone(NULL
, memc
);
296 test_true(memc_clone
);
299 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
300 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
301 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
302 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
305 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
306 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
307 test_true(memc_clone
->distribution
== memc
->distribution
);
308 { // Test all of the flags
309 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
310 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
311 test_true(memc_clone
->flags
.reuse_memory
== memc
->flags
.reuse_memory
);
312 test_true(memc_clone
->flags
.use_cache_lookups
== memc
->flags
.use_cache_lookups
);
313 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
314 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
315 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
316 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
317 test_true(memc_clone
->flags
.ketama_weighted
== memc
->flags
.ketama_weighted
);
318 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
319 test_true(memc_clone
->flags
.hash_with_prefix_key
== memc
->flags
.hash_with_prefix_key
);
320 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
321 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
322 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
323 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
325 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
326 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
327 test_true(hashkit_compare(&memc_clone
->distribution_hashkit
, &memc
->distribution_hashkit
));
328 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
329 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
330 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
331 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
332 test_true(memc_clone
->on_clone
== memc
->on_clone
);
333 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
334 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
335 test_true(memc_clone
->recv_size
== memc
->recv_size
);
336 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
337 test_true(memc_clone
->send_size
== memc
->send_size
);
338 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
339 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
340 test_true(memc_clone
->user_data
== memc
->user_data
);
342 memcached_free(memc_clone
);
345 /* Can we init from struct? */
347 memcached_st declared_clone
;
348 memcached_st
*memc_clone
;
349 memset(&declared_clone
, 0 , sizeof(memcached_st
));
350 memc_clone
= memcached_clone(&declared_clone
, NULL
);
351 test_true(memc_clone
);
352 memcached_free(memc_clone
);
355 /* Can we init from struct? */
357 memcached_st declared_clone
;
358 memcached_st
*memc_clone
;
359 memset(&declared_clone
, 0 , sizeof(memcached_st
));
360 memc_clone
= memcached_clone(&declared_clone
, memc
);
361 test_true(memc_clone
);
362 memcached_free(memc_clone
);
368 static test_return_t
userdata_test(memcached_st
*memc
)
371 test_true(memcached_set_user_data(memc
, foo
) == NULL
);
372 test_true(memcached_get_user_data(memc
) == foo
);
373 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
378 static test_return_t
connection_test(memcached_st
*memc
)
380 memcached_return_t rc
;
382 rc
= memcached_server_add_with_weight(memc
, "localhost", 0, 0);
383 test_true(rc
== MEMCACHED_SUCCESS
);
388 static test_return_t
error_test(memcached_st
*memc
)
390 memcached_return_t rc
;
391 uint32_t values
[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U,
392 982370485U, 1263635348U, 4242906218U, 3829656100U,
393 1891735253U, 334139633U, 2257084983U, 3088286104U,
394 13199785U, 2542027183U, 1097051614U, 199566778U,
395 2748246961U, 2465192557U, 1664094137U, 2405439045U,
396 1842224848U, 692413798U, 3479807801U, 919913813U,
397 4269430871U, 610793021U, 527273862U, 1437122909U,
398 2300930706U, 2943759320U, 674306647U, 2400528935U,
399 54481931U, 4186304426U, 1741088401U, 2979625118U,
400 4159057246U, 3425930182U, 2593724503U, 1868899624U,
401 1769812374U, 2302537950U, 1110330676U };
403 // You have updated the memcache_error messages but not updated docs/tests.
404 test_true(MEMCACHED_MAXIMUM_RETURN
== 43);
405 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
408 const char *msg
= memcached_strerror(memc
, rc
);
409 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
410 MEMCACHED_HASH_JENKINS
);
411 if (values
[rc
] != hash_val
)
413 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the error_test\n");
414 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, rc
), hash_val
);
416 test_true(values
[rc
] == hash_val
);
422 static test_return_t
set_test(memcached_st
*memc
)
424 memcached_return_t rc
;
425 const char *key
= "foo";
426 const char *value
= "when we sanitize";
428 rc
= memcached_set(memc
, key
, strlen(key
),
429 value
, strlen(value
),
430 (time_t)0, (uint32_t)0);
431 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
436 static test_return_t
append_test(memcached_st
*memc
)
438 memcached_return_t rc
;
439 const char *key
= "fig";
440 const char *in_value
= "we";
441 char *out_value
= NULL
;
445 rc
= memcached_flush(memc
, 0);
446 test_true(rc
== MEMCACHED_SUCCESS
);
448 rc
= memcached_set(memc
, key
, strlen(key
),
449 in_value
, strlen(in_value
),
450 (time_t)0, (uint32_t)0);
451 test_true(rc
== MEMCACHED_SUCCESS
);
453 rc
= memcached_append(memc
, key
, strlen(key
),
454 " the", strlen(" the"),
455 (time_t)0, (uint32_t)0);
456 test_true(rc
== MEMCACHED_SUCCESS
);
458 rc
= memcached_append(memc
, key
, strlen(key
),
459 " people", strlen(" people"),
460 (time_t)0, (uint32_t)0);
461 test_true(rc
== MEMCACHED_SUCCESS
);
463 out_value
= memcached_get(memc
, key
, strlen(key
),
464 &value_length
, &flags
, &rc
);
465 test_true(!memcmp(out_value
, "we the people", strlen("we the people")));
466 test_true(strlen("we the people") == value_length
);
467 test_true(rc
== MEMCACHED_SUCCESS
);
473 static test_return_t
append_binary_test(memcached_st
*memc
)
475 memcached_return_t rc
;
476 const char *key
= "numbers";
477 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
483 rc
= memcached_flush(memc
, 0);
484 test_true(rc
== MEMCACHED_SUCCESS
);
486 rc
= memcached_set(memc
,
489 (time_t)0, (uint32_t)0);
490 test_true(rc
== MEMCACHED_SUCCESS
);
492 for (x
= 0; store_list
[x
] ; x
++)
494 rc
= memcached_append(memc
,
496 (char *)&store_list
[x
], sizeof(uint32_t),
497 (time_t)0, (uint32_t)0);
498 test_true(rc
== MEMCACHED_SUCCESS
);
501 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
502 &value_length
, &flags
, &rc
);
503 test_true((value_length
== (sizeof(uint32_t) * x
)));
504 test_true(rc
== MEMCACHED_SUCCESS
);
506 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
508 test_true(*ptr
== store_list
[x
- counter
]);
516 static test_return_t
cas2_test(memcached_st
*memc
)
518 memcached_return_t rc
;
519 const char *keys
[]= {"fudge", "son", "food"};
520 size_t key_length
[]= {5, 3, 4};
521 const char *value
= "we the people";
522 size_t value_length
= strlen("we the people");
524 memcached_result_st results_obj
;
525 memcached_result_st
*results
;
528 rc
= memcached_flush(memc
, 0);
529 test_true(rc
== MEMCACHED_SUCCESS
);
531 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
533 for (x
= 0; x
< 3; x
++)
535 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
536 keys
[x
], key_length
[x
],
537 (time_t)50, (uint32_t)9);
538 test_true(rc
== MEMCACHED_SUCCESS
);
541 rc
= memcached_mget(memc
, keys
, key_length
, 3);
543 results
= memcached_result_create(memc
, &results_obj
);
545 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
547 test_true(results
->item_cas
);
548 test_true(rc
== MEMCACHED_SUCCESS
);
549 test_true(memcached_result_cas(results
));
551 test_true(!memcmp(value
, "we the people", strlen("we the people")));
552 test_true(strlen("we the people") == value_length
);
553 test_true(rc
== MEMCACHED_SUCCESS
);
555 memcached_result_free(&results_obj
);
560 static test_return_t
cas_test(memcached_st
*memc
)
562 memcached_return_t rc
;
563 const char *key
= "fun";
564 size_t key_length
= strlen(key
);
565 const char *value
= "we the people";
566 const char* keys
[2] = { key
, NULL
};
567 size_t keylengths
[2] = { strlen(key
), 0 };
568 size_t value_length
= strlen(value
);
569 const char *value2
= "change the value";
570 size_t value2_length
= strlen(value2
);
572 memcached_result_st results_obj
;
573 memcached_result_st
*results
;
576 rc
= memcached_flush(memc
, 0);
577 test_true(rc
== MEMCACHED_SUCCESS
);
579 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
581 rc
= memcached_set(memc
, key
, strlen(key
),
582 value
, strlen(value
),
583 (time_t)0, (uint32_t)0);
584 test_true(rc
== MEMCACHED_SUCCESS
);
586 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
588 results
= memcached_result_create(memc
, &results_obj
);
590 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
592 test_true(rc
== MEMCACHED_SUCCESS
);
593 test_true(memcached_result_cas(results
));
594 test_true(!memcmp(value
, memcached_result_value(results
), value_length
));
595 test_true(strlen(memcached_result_value(results
)) == value_length
);
596 test_true(rc
== MEMCACHED_SUCCESS
);
597 uint64_t cas
= memcached_result_cas(results
);
600 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
601 test_true(rc
== MEMCACHED_END
);
602 test_true(results
== NULL
);
605 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
606 test_true(rc
== MEMCACHED_SUCCESS
);
609 * The item will have a new cas value, so try to set it again with the old
610 * value. This should fail!
612 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
613 test_true(rc
== MEMCACHED_DATA_EXISTS
);
615 memcached_result_free(&results_obj
);
620 static test_return_t
prepend_test(memcached_st
*memc
)
622 memcached_return_t rc
;
623 const char *key
= "fig";
624 const char *value
= "people";
625 char *out_value
= NULL
;
629 rc
= memcached_flush(memc
, 0);
630 test_true(rc
== MEMCACHED_SUCCESS
);
632 rc
= memcached_set(memc
, key
, strlen(key
),
633 value
, strlen(value
),
634 (time_t)0, (uint32_t)0);
635 test_true(rc
== MEMCACHED_SUCCESS
);
637 rc
= memcached_prepend(memc
, key
, strlen(key
),
638 "the ", strlen("the "),
639 (time_t)0, (uint32_t)0);
640 test_true(rc
== MEMCACHED_SUCCESS
);
642 rc
= memcached_prepend(memc
, key
, strlen(key
),
643 "we ", strlen("we "),
644 (time_t)0, (uint32_t)0);
645 test_true(rc
== MEMCACHED_SUCCESS
);
647 out_value
= memcached_get(memc
, key
, strlen(key
),
648 &value_length
, &flags
, &rc
);
649 test_true(!memcmp(out_value
, "we the people", strlen("we the people")));
650 test_true(strlen("we the people") == value_length
);
651 test_true(rc
== MEMCACHED_SUCCESS
);
658 Set the value, then quit to make sure it is flushed.
659 Come back in and test that add fails.
661 static test_return_t
add_test(memcached_st
*memc
)
663 memcached_return_t rc
;
664 const char *key
= "foo";
665 const char *value
= "when we sanitize";
666 unsigned long long setting_value
;
668 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
670 rc
= memcached_set(memc
, key
, strlen(key
),
671 value
, strlen(value
),
672 (time_t)0, (uint32_t)0);
673 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
674 memcached_quit(memc
);
675 rc
= memcached_add(memc
, key
, strlen(key
),
676 value
, strlen(value
),
677 (time_t)0, (uint32_t)0);
679 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
682 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
686 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
693 ** There was a problem of leaking filedescriptors in the initial release
694 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
695 ** systems it seems that the kernel is slow on reclaiming the resources
696 ** because the connects starts to time out (the test doesn't do much
697 ** anyway, so just loop 10 iterations)
699 static test_return_t
add_wrapper(memcached_st
*memc
)
701 unsigned int max
= 10000;
709 for (uint32_t x
= 0; x
< max
; x
++)
715 static test_return_t
replace_test(memcached_st
*memc
)
717 memcached_return_t rc
;
718 const char *key
= "foo";
719 const char *value
= "when we sanitize";
720 const char *original
= "first we insert some data";
722 rc
= memcached_set(memc
, key
, strlen(key
),
723 original
, strlen(original
),
724 (time_t)0, (uint32_t)0);
725 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
727 rc
= memcached_replace(memc
, key
, strlen(key
),
728 value
, strlen(value
),
729 (time_t)0, (uint32_t)0);
730 test_true(rc
== MEMCACHED_SUCCESS
);
735 static test_return_t
delete_test(memcached_st
*memc
)
737 memcached_return_t rc
;
738 const char *key
= "foo";
739 const char *value
= "when we sanitize";
741 rc
= memcached_set(memc
, key
, strlen(key
),
742 value
, strlen(value
),
743 (time_t)0, (uint32_t)0);
744 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
746 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
747 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
752 static test_return_t
flush_test(memcached_st
*memc
)
754 memcached_return_t rc
;
756 rc
= memcached_flush(memc
, 0);
757 test_true(rc
== MEMCACHED_SUCCESS
);
762 static memcached_return_t
server_function(const memcached_st
*ptr
__attribute__((unused
)),
763 const memcached_server_st
*server
__attribute__((unused
)),
764 void *context
__attribute__((unused
)))
768 return MEMCACHED_SUCCESS
;
771 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
774 strcpy(context
, "foo bad");
775 memcached_server_fn callbacks
[1];
777 callbacks
[0]= server_function
;
778 memcached_server_cursor(memc
, callbacks
, context
, 1);
782 static test_return_t
bad_key_test(memcached_st
*memc
)
784 memcached_return_t rc
;
785 const char *key
= "foo bad";
787 size_t string_length
;
789 memcached_st
*memc_clone
;
791 size_t max_keylen
= 0xffff;
793 // Just skip if we are in binary mode.
794 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
797 memc_clone
= memcached_clone(NULL
, memc
);
798 test_true(memc_clone
);
800 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
801 test_true(rc
== MEMCACHED_SUCCESS
);
803 /* All keys are valid in the binary protocol (except for length) */
804 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 0)
806 string
= memcached_get(memc_clone
, key
, strlen(key
),
807 &string_length
, &flags
, &rc
);
808 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
809 test_true(string_length
== 0);
813 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
814 test_true(rc
== MEMCACHED_SUCCESS
);
815 string
= memcached_get(memc_clone
, key
, strlen(key
),
816 &string_length
, &flags
, &rc
);
817 test_true(rc
== MEMCACHED_NOTFOUND
);
818 test_true(string_length
== 0);
821 /* Test multi key for bad keys */
822 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
823 size_t key_lengths
[] = { 7, 7, 7 };
825 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
826 test_true(rc
== MEMCACHED_SUCCESS
);
828 rc
= memcached_mget(memc_clone
, keys
, key_lengths
, 3);
829 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
831 rc
= memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1);
832 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
836 /* The following test should be moved to the end of this function when the
837 memcached server is updated to allow max size length of the keys in the
840 rc
= memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
841 test_true(rc
== MEMCACHED_SUCCESS
);
843 char *longkey
= malloc(max_keylen
+ 1);
846 memset(longkey
, 'a', max_keylen
+ 1);
847 string
= memcached_get(memc_clone
, longkey
, max_keylen
,
848 &string_length
, &flags
, &rc
);
849 test_true(rc
== MEMCACHED_NOTFOUND
);
850 test_true(string_length
== 0);
853 string
= memcached_get(memc_clone
, longkey
, max_keylen
+ 1,
854 &string_length
, &flags
, &rc
);
855 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
856 test_true(string_length
== 0);
863 /* Make sure zero length keys are marked as bad */
865 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
866 test_true(rc
== MEMCACHED_SUCCESS
);
867 string
= memcached_get(memc_clone
, key
, 0,
868 &string_length
, &flags
, &rc
);
869 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
870 test_true(string_length
== 0);
873 memcached_free(memc_clone
);
878 #define READ_THROUGH_VALUE "set for me"
879 static memcached_return_t
read_through_trigger(memcached_st
*memc
__attribute__((unused
)),
880 char *key
__attribute__((unused
)),
881 size_t key_length
__attribute__((unused
)),
882 memcached_result_st
*result
)
885 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
888 static test_return_t
read_through(memcached_st
*memc
)
890 memcached_return_t rc
;
891 const char *key
= "foo";
893 size_t string_length
;
895 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
897 string
= memcached_get(memc
, key
, strlen(key
),
898 &string_length
, &flags
, &rc
);
900 test_true(rc
== MEMCACHED_NOTFOUND
);
901 test_false(string_length
);
904 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
,
906 test_true(rc
== MEMCACHED_SUCCESS
);
908 string
= memcached_get(memc
, key
, strlen(key
),
909 &string_length
, &flags
, &rc
);
911 test_true(rc
== MEMCACHED_SUCCESS
);
912 test_true(string_length
== strlen(READ_THROUGH_VALUE
));
913 test_strcmp(READ_THROUGH_VALUE
, string
);
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_true(!strcmp(READ_THROUGH_VALUE
, string
));
927 static memcached_return_t
delete_trigger(memcached_st
*ptr
__attribute__((unused
)),
929 size_t key_length
__attribute__((unused
)))
933 return MEMCACHED_SUCCESS
;
936 static test_return_t
delete_through(memcached_st
*memc
)
938 memcached_trigger_delete_key_fn callback
;
939 memcached_return_t rc
;
941 callback
= (memcached_trigger_delete_key_fn
)delete_trigger
;
943 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
944 test_true(rc
== MEMCACHED_SUCCESS
);
949 static test_return_t
get_test(memcached_st
*memc
)
951 memcached_return_t rc
;
952 const char *key
= "foo";
954 size_t string_length
;
957 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
958 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
960 string
= memcached_get(memc
, key
, strlen(key
),
961 &string_length
, &flags
, &rc
);
963 test_true(rc
== MEMCACHED_NOTFOUND
);
964 test_false(string_length
);
970 static test_return_t
get_test2(memcached_st
*memc
)
972 memcached_return_t rc
;
973 const char *key
= "foo";
974 const char *value
= "when we sanitize";
976 size_t string_length
;
979 rc
= memcached_set(memc
, key
, strlen(key
),
980 value
, strlen(value
),
981 (time_t)0, (uint32_t)0);
982 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
984 string
= memcached_get(memc
, key
, strlen(key
),
985 &string_length
, &flags
, &rc
);
988 test_true(rc
== MEMCACHED_SUCCESS
);
989 test_true(string_length
== strlen(value
));
990 test_true(!memcmp(string
, value
, string_length
));
997 static test_return_t
set_test2(memcached_st
*memc
)
999 memcached_return_t rc
;
1000 const char *key
= "foo";
1001 const char *value
= "train in the brain";
1002 size_t value_length
= strlen(value
);
1005 for (x
= 0; x
< 10; x
++)
1007 rc
= memcached_set(memc
, key
, strlen(key
),
1008 value
, value_length
,
1009 (time_t)0, (uint32_t)0);
1010 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1013 return TEST_SUCCESS
;
1016 static test_return_t
set_test3(memcached_st
*memc
)
1018 memcached_return_t rc
;
1020 size_t value_length
= 8191;
1023 value
= (char*)malloc(value_length
);
1026 for (x
= 0; x
< value_length
; x
++)
1027 value
[x
] = (char) (x
% 127);
1029 /* The dump test relies on there being at least 32 items in memcached */
1030 for (x
= 0; x
< 32; x
++)
1034 snprintf(key
, sizeof(key
), "foo%u", x
);
1036 rc
= memcached_set(memc
, key
, strlen(key
),
1037 value
, value_length
,
1038 (time_t)0, (uint32_t)0);
1039 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1044 return TEST_SUCCESS
;
1047 static test_return_t
get_test3(memcached_st
*memc
)
1049 memcached_return_t rc
;
1050 const char *key
= "foo";
1052 size_t value_length
= 8191;
1054 size_t string_length
;
1058 value
= (char*)malloc(value_length
);
1061 for (x
= 0; x
< value_length
; x
++)
1062 value
[x
] = (char) (x
% 127);
1064 rc
= memcached_set(memc
, key
, strlen(key
),
1065 value
, value_length
,
1066 (time_t)0, (uint32_t)0);
1067 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1069 string
= memcached_get(memc
, key
, strlen(key
),
1070 &string_length
, &flags
, &rc
);
1072 test_true(rc
== MEMCACHED_SUCCESS
);
1074 test_true(string_length
== value_length
);
1075 test_true(!memcmp(string
, value
, string_length
));
1080 return TEST_SUCCESS
;
1083 static test_return_t
get_test4(memcached_st
*memc
)
1085 memcached_return_t rc
;
1086 const char *key
= "foo";
1088 size_t value_length
= 8191;
1090 size_t string_length
;
1094 value
= (char*)malloc(value_length
);
1097 for (x
= 0; x
< value_length
; x
++)
1098 value
[x
] = (char) (x
% 127);
1100 rc
= memcached_set(memc
, key
, strlen(key
),
1101 value
, value_length
,
1102 (time_t)0, (uint32_t)0);
1103 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1105 for (x
= 0; x
< 10; x
++)
1107 string
= memcached_get(memc
, key
, strlen(key
),
1108 &string_length
, &flags
, &rc
);
1110 test_true(rc
== MEMCACHED_SUCCESS
);
1112 test_true(string_length
== value_length
);
1113 test_true(!memcmp(string
, value
, string_length
));
1119 return TEST_SUCCESS
;
1123 * This test verifies that memcached_read_one_response doesn't try to
1124 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1125 * responses before you execute a storage command.
1127 static test_return_t
get_test5(memcached_st
*memc
)
1130 ** Request the same key twice, to ensure that we hash to the same server
1131 ** (so that we have multiple response values queued up) ;-)
1133 const char *keys
[]= { "key", "key" };
1134 size_t lengths
[]= { 3, 3 };
1138 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1139 keys
[0], lengths
[0], 0, 0);
1140 test_true(rc
== MEMCACHED_SUCCESS
);
1141 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1143 memcached_result_st results_obj
;
1144 memcached_result_st
*results
;
1145 results
=memcached_result_create(memc
, &results_obj
);
1147 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
1149 memcached_result_free(&results_obj
);
1151 /* Don't read out the second result, but issue a set instead.. */
1152 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
1153 test_true(rc
== MEMCACHED_SUCCESS
);
1155 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1156 &rlen
, &flags
, &rc
);
1157 test_true(val
== NULL
);
1158 test_true(rc
== MEMCACHED_NOTFOUND
);
1159 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1160 test_true(val
!= NULL
);
1161 test_true(rc
== MEMCACHED_SUCCESS
);
1164 return TEST_SUCCESS
;
1167 static test_return_t
mget_end(memcached_st
*memc
)
1169 const char *keys
[]= { "foo", "foo2" };
1170 size_t lengths
[]= { 3, 4 };
1171 const char *values
[]= { "fjord", "41" };
1173 memcached_return_t rc
;
1176 for (int i
= 0; i
< 2; i
++)
1178 rc
= memcached_set(memc
, keys
[i
], lengths
[i
], values
[i
], strlen(values
[i
]),
1179 (time_t)0, (uint32_t)0);
1180 test_true(rc
== MEMCACHED_SUCCESS
);
1184 size_t string_length
;
1187 // retrieve both via mget
1188 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1189 test_true(rc
== MEMCACHED_SUCCESS
);
1191 char key
[MEMCACHED_MAX_KEY
];
1194 // this should get both
1195 for (int i
= 0; i
< 2; i
++)
1197 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1199 test_true(rc
== MEMCACHED_SUCCESS
);
1201 if (key_length
== 4)
1203 test_true(string_length
== strlen(values
[val
]));
1204 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1208 // this should indicate end
1209 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1210 test_true(rc
== MEMCACHED_END
);
1213 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1214 test_true(rc
== MEMCACHED_SUCCESS
);
1216 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1217 test_true(key_length
== lengths
[0]);
1218 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1219 test_true(string_length
== strlen(values
[0]));
1220 test_true(strncmp(values
[0], string
, string_length
) == 0);
1221 test_true(rc
== MEMCACHED_SUCCESS
);
1224 // this should indicate end
1225 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1226 test_true(rc
== MEMCACHED_END
);
1228 return TEST_SUCCESS
;
1231 /* Do not copy the style of this code, I just access hosts to testthis function */
1232 static test_return_t
stats_servername_test(memcached_st
*memc
)
1234 memcached_return_t rc
;
1235 memcached_stat_st memc_stat
;
1236 memcached_server_instance_st instance
=
1237 memcached_server_instance_by_position(memc
, 0);
1239 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
1240 if (memcached_get_sasl_callbacks(memc
) != NULL
)
1241 return TEST_SKIPPED
;
1243 rc
= memcached_stat_servername(&memc_stat
, NULL
,
1244 memcached_server_name(instance
),
1245 memcached_server_port(instance
));
1247 return TEST_SUCCESS
;
1250 static test_return_t
increment_test(memcached_st
*memc
)
1252 uint64_t new_number
;
1253 memcached_return_t rc
;
1254 const char *key
= "number";
1255 const char *value
= "0";
1257 rc
= memcached_set(memc
, key
, strlen(key
),
1258 value
, strlen(value
),
1259 (time_t)0, (uint32_t)0);
1260 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1262 rc
= memcached_increment(memc
, key
, strlen(key
),
1264 test_true(rc
== MEMCACHED_SUCCESS
);
1265 test_true(new_number
== 1);
1267 rc
= memcached_increment(memc
, key
, strlen(key
),
1269 test_true(rc
== MEMCACHED_SUCCESS
);
1270 test_true(new_number
== 2);
1272 return TEST_SUCCESS
;
1275 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1277 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1279 uint64_t new_number
;
1280 memcached_return_t rc
;
1281 const char *key
= "number";
1282 uint64_t initial
= 0;
1284 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1285 1, initial
, 0, &new_number
);
1286 test_true(rc
== MEMCACHED_SUCCESS
);
1287 test_true(new_number
== initial
);
1289 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1290 1, initial
, 0, &new_number
);
1291 test_true(rc
== MEMCACHED_SUCCESS
);
1292 test_true(new_number
== (initial
+ 1));
1294 return TEST_SUCCESS
;
1297 static test_return_t
decrement_test(memcached_st
*memc
)
1299 uint64_t new_number
;
1300 memcached_return_t rc
;
1301 const char *key
= "number";
1302 const char *value
= "3";
1304 rc
= memcached_set(memc
, key
, strlen(key
),
1305 value
, strlen(value
),
1306 (time_t)0, (uint32_t)0);
1307 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1309 rc
= memcached_decrement(memc
, key
, strlen(key
),
1311 test_true(rc
== MEMCACHED_SUCCESS
);
1312 test_true(new_number
== 2);
1314 rc
= memcached_decrement(memc
, key
, strlen(key
),
1316 test_true(rc
== MEMCACHED_SUCCESS
);
1317 test_true(new_number
== 1);
1319 return TEST_SUCCESS
;
1322 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1324 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1326 uint64_t new_number
;
1327 memcached_return_t rc
;
1328 const char *key
= "number";
1329 uint64_t initial
= 3;
1331 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1332 1, initial
, 0, &new_number
);
1333 test_true(rc
== MEMCACHED_SUCCESS
);
1334 test_true(new_number
== initial
);
1336 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1337 1, initial
, 0, &new_number
);
1338 test_true(rc
== MEMCACHED_SUCCESS
);
1339 test_true(new_number
== (initial
- 1));
1341 return TEST_SUCCESS
;
1344 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1346 uint64_t new_number
;
1347 memcached_return_t rc
;
1348 const char *master_key
= "foo";
1349 const char *key
= "number";
1350 const char *value
= "0";
1352 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1354 value
, strlen(value
),
1355 (time_t)0, (uint32_t)0);
1356 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1358 rc
= memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1360 test_true(rc
== MEMCACHED_SUCCESS
);
1361 test_true(new_number
== 1);
1363 rc
= memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1365 test_true(rc
== MEMCACHED_SUCCESS
);
1366 test_true(new_number
== 2);
1368 return TEST_SUCCESS
;
1371 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1373 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1375 uint64_t new_number
;
1376 memcached_return_t rc
;
1377 const char *master_key
= "foo";
1378 const char *key
= "number";
1379 uint64_t initial
= 0;
1381 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1383 1, initial
, 0, &new_number
);
1384 test_true(rc
== MEMCACHED_SUCCESS
);
1385 test_true(new_number
== initial
);
1387 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1389 1, initial
, 0, &new_number
);
1390 test_true(rc
== MEMCACHED_SUCCESS
);
1391 test_true(new_number
== (initial
+ 1));
1393 return TEST_SUCCESS
;
1396 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1398 uint64_t new_number
;
1399 memcached_return_t rc
;
1400 const char *master_key
= "foo";
1401 const char *key
= "number";
1402 const char *value
= "3";
1404 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1406 value
, strlen(value
),
1407 (time_t)0, (uint32_t)0);
1408 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1410 rc
= memcached_decrement_by_key(memc
, master_key
, strlen(master_key
),
1413 test_true(rc
== MEMCACHED_SUCCESS
);
1414 test_true(new_number
== 2);
1416 rc
= memcached_decrement_by_key(memc
, master_key
, strlen(master_key
),
1419 test_true(rc
== MEMCACHED_SUCCESS
);
1420 test_true(new_number
== 1);
1422 return TEST_SUCCESS
;
1425 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1427 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1429 uint64_t new_number
;
1430 memcached_return_t rc
;
1431 const char *master_key
= "foo";
1432 const char *key
= "number";
1433 uint64_t initial
= 3;
1435 rc
= memcached_decrement_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1437 1, initial
, 0, &new_number
);
1438 test_true(rc
== MEMCACHED_SUCCESS
);
1439 test_true(new_number
== initial
);
1441 rc
= memcached_decrement_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1443 1, initial
, 0, &new_number
);
1444 test_true(rc
== MEMCACHED_SUCCESS
);
1445 test_true(new_number
== (initial
- 1));
1447 return TEST_SUCCESS
;
1450 static test_return_t
quit_test(memcached_st
*memc
)
1452 memcached_return_t rc
;
1453 const char *key
= "fudge";
1454 const char *value
= "sanford and sun";
1456 rc
= memcached_set(memc
, key
, strlen(key
),
1457 value
, strlen(value
),
1458 (time_t)10, (uint32_t)3);
1459 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1460 memcached_quit(memc
);
1462 rc
= memcached_set(memc
, key
, strlen(key
),
1463 value
, strlen(value
),
1464 (time_t)50, (uint32_t)9);
1465 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1467 return TEST_SUCCESS
;
1470 static test_return_t
mget_result_test(memcached_st
*memc
)
1472 memcached_return_t rc
;
1473 const char *keys
[]= {"fudge", "son", "food"};
1474 size_t key_length
[]= {5, 3, 4};
1477 memcached_result_st results_obj
;
1478 memcached_result_st
*results
;
1480 results
= memcached_result_create(memc
, &results_obj
);
1482 test_true(&results_obj
== results
);
1484 /* We need to empty the server before continueing test */
1485 rc
= memcached_flush(memc
, 0);
1486 test_true(rc
== MEMCACHED_SUCCESS
);
1488 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1489 test_true(rc
== MEMCACHED_SUCCESS
);
1491 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1496 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1497 test_true(!results
);
1498 test_true(rc
== MEMCACHED_END
);
1500 for (x
= 0; x
< 3; x
++)
1502 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1503 keys
[x
], key_length
[x
],
1504 (time_t)50, (uint32_t)9);
1505 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1508 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1509 test_true(rc
== MEMCACHED_SUCCESS
);
1511 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1514 test_true(&results_obj
== results
);
1515 test_true(rc
== MEMCACHED_SUCCESS
);
1516 test_true(memcached_result_key_length(results
) == memcached_result_length(results
));
1517 test_true(!memcmp(memcached_result_key_value(results
),
1518 memcached_result_value(results
),
1519 memcached_result_length(results
)));
1522 memcached_result_free(&results_obj
);
1524 return TEST_SUCCESS
;
1527 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1529 memcached_return_t rc
;
1530 const char *keys
[]= {"fudge", "son", "food"};
1531 size_t key_length
[]= {5, 3, 4};
1534 memcached_result_st
*results
;
1536 /* We need to empty the server before continueing test */
1537 rc
= memcached_flush(memc
, 0);
1538 test_true(rc
== MEMCACHED_SUCCESS
);
1540 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1541 test_true(rc
== MEMCACHED_SUCCESS
);
1543 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
1547 test_true(!results
);
1548 test_true(rc
== MEMCACHED_END
);
1550 for (x
= 0; x
< 3; x
++)
1552 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1553 keys
[x
], key_length
[x
],
1554 (time_t)50, (uint32_t)9);
1555 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1558 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1559 test_true(rc
== MEMCACHED_SUCCESS
);
1562 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1565 test_true(rc
== MEMCACHED_SUCCESS
);
1566 test_true(memcached_result_key_length(results
) == memcached_result_length(results
));
1567 test_true(!memcmp(memcached_result_key_value(results
),
1568 memcached_result_value(results
),
1569 memcached_result_length(results
)));
1570 memcached_result_free(results
);
1574 return TEST_SUCCESS
;
1577 /* Count the results */
1578 static memcached_return_t
callback_counter(const memcached_st
*ptr
__attribute__((unused
)),
1579 memcached_result_st
*result
__attribute__((unused
)),
1582 size_t *counter
= (size_t *)context
;
1584 *counter
= *counter
+ 1;
1586 return MEMCACHED_SUCCESS
;
1589 static test_return_t
mget_result_function(memcached_st
*memc
)
1591 memcached_return_t rc
;
1592 const char *keys
[]= {"fudge", "son", "food"};
1593 size_t key_length
[]= {5, 3, 4};
1596 memcached_execute_fn callbacks
[1];
1598 /* We need to empty the server before continueing test */
1599 rc
= memcached_flush(memc
, 0);
1600 for (x
= 0; x
< 3; x
++)
1602 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1603 keys
[x
], key_length
[x
],
1604 (time_t)50, (uint32_t)9);
1605 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1608 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1609 test_true(rc
== MEMCACHED_SUCCESS
);
1611 callbacks
[0]= &callback_counter
;
1613 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1615 test_true(counter
== 3);
1617 return TEST_SUCCESS
;
1620 static test_return_t
mget_test(memcached_st
*memc
)
1622 memcached_return_t rc
;
1623 const char *keys
[]= {"fudge", "son", "food"};
1624 size_t key_length
[]= {5, 3, 4};
1628 char return_key
[MEMCACHED_MAX_KEY
];
1629 size_t return_key_length
;
1631 size_t return_value_length
;
1633 /* We need to empty the server before continueing test */
1634 rc
= memcached_flush(memc
, 0);
1635 test_true(rc
== MEMCACHED_SUCCESS
);
1637 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1638 test_true(rc
== MEMCACHED_SUCCESS
);
1640 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1641 &return_value_length
, &flags
, &rc
)) != NULL
)
1643 test_true(return_value
);
1645 test_true(!return_value
);
1646 test_true(return_value_length
== 0);
1647 test_true(rc
== MEMCACHED_END
);
1649 for (x
= 0; x
< 3; x
++)
1651 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1652 keys
[x
], key_length
[x
],
1653 (time_t)50, (uint32_t)9);
1654 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1657 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1658 test_true(rc
== MEMCACHED_SUCCESS
);
1661 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1662 &return_value_length
, &flags
, &rc
)))
1664 test_true(return_value
);
1665 test_true(rc
== MEMCACHED_SUCCESS
);
1666 test_true(return_key_length
== return_value_length
);
1667 test_true(!memcmp(return_value
, return_key
, return_value_length
));
1672 return TEST_SUCCESS
;
1675 static test_return_t
mget_execute(memcached_st
*memc
)
1679 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1683 * I only want to hit _one_ server so I know the number of requests I'm
1684 * sending in the pipeline.
1686 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1687 memc
->number_of_hosts
= 1;
1689 size_t max_keys
= 20480;
1692 char **keys
= calloc(max_keys
, sizeof(char*));
1693 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
1695 /* First add all of the items.. */
1696 char blob
[1024] = {0};
1697 memcached_return_t rc
;
1699 for (size_t x
= 0; x
< max_keys
; ++x
)
1703 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1705 test_true(keys
[x
] != NULL
);
1706 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1707 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1710 /* Try to get all of them with a large multiget */
1712 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
1713 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1714 max_keys
, callbacks
, &counter
, 1);
1716 if (rc
== MEMCACHED_SUCCESS
)
1719 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1720 test_true(rc
== MEMCACHED_END
);
1722 /* Verify that we got all of the items */
1723 test_true(counter
== max_keys
);
1725 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1727 test_true(counter
== 0);
1731 test_fail("note: this test functions differently when in binary mode");
1734 /* Release all allocated resources */
1735 for (size_t x
= 0; x
< max_keys
; ++x
)
1742 memc
->number_of_hosts
= number_of_hosts
;
1743 return TEST_SUCCESS
;
1746 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1748 static test_return_t
key_setup(memcached_st
*memc
)
1752 if (pre_binary(memc
) != TEST_SUCCESS
)
1753 return TEST_SKIPPED
;
1755 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1757 return TEST_SUCCESS
;
1760 static test_return_t
key_teardown(memcached_st
*memc
)
1763 pairs_free(global_pairs
);
1765 return TEST_SUCCESS
;
1768 static test_return_t
block_add_regression(memcached_st
*memc
)
1770 /* First add all of the items.. */
1771 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1773 memcached_return_t rc
;
1774 char blob
[1024] = {0};
1776 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1777 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1780 return TEST_SUCCESS
;
1783 static test_return_t
binary_add_regression(memcached_st
*memc
)
1785 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1786 test_return_t rc
= block_add_regression(memc
);
1787 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1791 static test_return_t
get_stats_keys(memcached_st
*memc
)
1795 memcached_stat_st memc_stat
;
1796 memcached_return_t rc
;
1798 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1799 test_true(rc
== MEMCACHED_SUCCESS
);
1800 for (ptr
= stat_list
; *ptr
; ptr
++)
1805 return TEST_SUCCESS
;
1808 static test_return_t
version_string_test(memcached_st
*memc
__attribute__((unused
)))
1810 const char *version_string
;
1812 version_string
= memcached_lib_version();
1814 test_true(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1816 return TEST_SUCCESS
;
1819 static test_return_t
get_stats(memcached_st
*memc
)
1823 memcached_return_t rc
;
1824 memcached_stat_st
*memc_stat
;
1826 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1827 test_true(rc
== MEMCACHED_SUCCESS
);
1829 test_true(rc
== MEMCACHED_SUCCESS
);
1830 test_true(memc_stat
);
1832 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1834 stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1835 test_true(rc
== MEMCACHED_SUCCESS
);
1836 for (ptr
= stat_list
; *ptr
; ptr
++);
1841 memcached_stat_free(NULL
, memc_stat
);
1843 return TEST_SUCCESS
;
1846 static test_return_t
add_host_test(memcached_st
*memc
)
1849 memcached_server_st
*servers
;
1850 memcached_return_t rc
;
1851 char servername
[]= "0.example.com";
1853 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1855 test_true(1 == memcached_server_list_count(servers
));
1857 for (x
= 2; x
< 20; x
++)
1859 char buffer
[SMALL_STRING_LEN
];
1861 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1862 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1864 test_true(rc
== MEMCACHED_SUCCESS
);
1865 test_true(x
== memcached_server_list_count(servers
));
1868 rc
= memcached_server_push(memc
, servers
);
1869 test_true(rc
== MEMCACHED_SUCCESS
);
1870 rc
= memcached_server_push(memc
, servers
);
1871 test_true(rc
== MEMCACHED_SUCCESS
);
1873 memcached_server_list_free(servers
);
1875 return TEST_SUCCESS
;
1878 static memcached_return_t
clone_test_callback(memcached_st
*parent
__attribute__((unused
)), memcached_st
*memc_clone
__attribute__((unused
)))
1880 return MEMCACHED_SUCCESS
;
1883 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
__attribute__((unused
)))
1885 return MEMCACHED_SUCCESS
;
1888 static test_return_t
callback_test(memcached_st
*memc
)
1890 /* Test User Data */
1894 memcached_return_t rc
;
1896 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1897 test_true(rc
== MEMCACHED_SUCCESS
);
1898 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1899 test_true(*test_ptr
== x
);
1902 /* Test Clone Callback */
1904 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1905 void *clone_cb_ptr
= *(void **)&clone_cb
;
1906 void *temp_function
= NULL
;
1907 memcached_return_t rc
;
1909 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1911 test_true(rc
== MEMCACHED_SUCCESS
);
1912 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1913 test_true(temp_function
== clone_cb_ptr
);
1916 /* Test Cleanup Callback */
1918 memcached_cleanup_fn cleanup_cb
=
1919 (memcached_cleanup_fn
)cleanup_test_callback
;
1920 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1921 void *temp_function
= NULL
;
1922 memcached_return_t rc
;
1924 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1926 test_true(rc
== MEMCACHED_SUCCESS
);
1927 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1928 test_true(temp_function
== cleanup_cb_ptr
);
1931 return TEST_SUCCESS
;
1934 /* We don't test the behavior itself, we test the switches */
1935 static test_return_t
behavior_test(memcached_st
*memc
)
1940 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1941 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1942 test_true(value
== 1);
1944 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1945 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1946 test_true(value
== 1);
1948 set
= MEMCACHED_HASH_MD5
;
1949 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1950 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1951 test_true(value
== MEMCACHED_HASH_MD5
);
1955 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1956 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1957 test_true(value
== 0);
1959 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1960 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1961 test_true(value
== 0);
1963 set
= MEMCACHED_HASH_DEFAULT
;
1964 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1965 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1966 test_true(value
== MEMCACHED_HASH_DEFAULT
);
1968 set
= MEMCACHED_HASH_CRC
;
1969 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1970 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1971 test_true(value
== MEMCACHED_HASH_CRC
);
1973 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1974 test_true(value
> 0);
1976 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1977 test_true(value
> 0);
1979 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
1980 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
1981 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
1983 return TEST_SUCCESS
;
1986 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
1988 memcached_return_t rc
;
1992 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
1993 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
1995 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
1997 if (rc
== MEMCACHED_SUCCESS
)
1999 test_true((bool)value
== set
);
2003 test_false((bool)value
== set
);
2006 return TEST_SUCCESS
;
2010 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2012 memcached_return_t rc
;
2016 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, set
);
2017 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2019 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2021 if (rc
== MEMCACHED_SUCCESS
)
2023 test_true((bool)value
== set
);
2027 test_false((bool)value
== set
);
2030 return TEST_SUCCESS
;
2034 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2036 memcached_return_t rc
;
2040 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, set
);
2041 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2043 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2045 if (rc
== MEMCACHED_SUCCESS
)
2047 test_true((bool)value
== set
);
2051 test_false((bool)value
== set
);
2054 return TEST_SUCCESS
;
2057 static test_return_t
fetch_all_results(memcached_st
*memc
, size_t *keys_returned
)
2059 memcached_return_t rc
= MEMCACHED_SUCCESS
;
2060 char return_key
[MEMCACHED_MAX_KEY
];
2061 size_t return_key_length
;
2063 size_t return_value_length
;
2068 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2069 &return_value_length
, &flags
, &rc
)))
2071 test_true(return_value
);
2072 test_true(rc
== MEMCACHED_SUCCESS
);
2074 *keys_returned
= *keys_returned
+1;
2077 test_true_got(rc
== MEMCACHED_END
|| rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
2079 return TEST_SUCCESS
;
2082 /* Test case provided by Cal Haldenbrand */
2083 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2085 unsigned int setter
= 1;
2087 unsigned long long total
= 0;
2090 char randomstuff
[6 * 1024];
2091 memcached_return_t rc
;
2093 memset(randomstuff
, 0, 6 * 1024);
2095 /* We just keep looking at the same values over and over */
2098 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2099 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2103 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2107 size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2108 memset(randomstuff
, 0, 6 * 1024);
2109 test_true(size
< 6 * 1024); /* Being safe here */
2111 for (j
= 0 ; j
< size
;j
++)
2112 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2115 snprintf(key
, sizeof(key
), "%u", x
);
2116 rc
= memcached_set(memc
, key
, strlen(key
),
2117 randomstuff
, strlen(randomstuff
), 10, 0);
2118 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2119 /* If we fail, lets try again */
2120 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
2121 rc
= memcached_set(memc
, key
, strlen(key
),
2122 randomstuff
, strlen(randomstuff
), 10, 0);
2123 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2126 return TEST_SUCCESS
;
2129 /* Test case provided by Cal Haldenbrand */
2130 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2132 unsigned int setter
;
2136 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2137 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2139 setter
= 20 * 1024576;
2140 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2141 setter
= 20 * 1024576;
2142 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2143 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2144 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2146 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2149 for (uint32_t x
= 0, errors
= 0; total
< 24576 ; x
++)
2151 memcached_return_t rc
= MEMCACHED_SUCCESS
;
2152 char buffer
[SMALL_STRING_LEN
];
2157 memset(buffer
, 0, SMALL_STRING_LEN
);
2159 snprintf(buffer
, sizeof(buffer
), "%u", x
);
2160 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
2161 &val_len
, &flags
, &rc
);
2162 if (rc
!= MEMCACHED_SUCCESS
)
2164 if (rc
== MEMCACHED_NOTFOUND
)
2178 return TEST_SUCCESS
;
2181 /* Do a large mget() over all the keys we think exist */
2182 #define KEY_COUNT 3000 // * 1024576
2183 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2185 memcached_return_t rc
;
2186 unsigned int setter
;
2189 size_t key_lengths
[KEY_COUNT
];
2192 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2193 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2195 setter
= 20 * 1024576;
2196 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2197 setter
= 20 * 1024576;
2198 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2199 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2200 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2203 keys
= calloc(KEY_COUNT
, sizeof(char *));
2205 for (x
= 0; x
< KEY_COUNT
; x
++)
2209 snprintf(buffer
, 30, "%u", x
);
2210 keys
[x
]= strdup(buffer
);
2211 key_lengths
[x
]= strlen(keys
[x
]);
2214 rc
= memcached_mget(memc
, (const char **)keys
, key_lengths
, KEY_COUNT
);
2215 test_true(rc
== MEMCACHED_SUCCESS
);
2217 size_t keys_returned
;
2218 test_true(fetch_all_results(memc
, &keys_returned
) == TEST_SUCCESS
);
2220 for (x
= 0; x
< KEY_COUNT
; x
++)
2224 return TEST_SUCCESS
;
2227 /* Make sure we behave properly if server list has no values */
2228 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2230 memcached_return_t rc
;
2231 const char *keys
[]= {"fudge", "son", "food"};
2232 size_t key_length
[]= {5, 3, 4};
2235 char return_key
[MEMCACHED_MAX_KEY
];
2236 size_t return_key_length
;
2238 size_t return_value_length
;
2240 /* Here we free everything before running a bunch of mget tests */
2241 memcached_servers_reset(memc
);
2244 /* We need to empty the server before continueing test */
2245 rc
= memcached_flush(memc
, 0);
2246 test_true(rc
== MEMCACHED_NO_SERVERS
);
2248 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2249 test_true(rc
== MEMCACHED_NO_SERVERS
);
2251 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2252 &return_value_length
, &flags
, &rc
)) != NULL
)
2254 test_true(return_value
);
2256 test_true(!return_value
);
2257 test_true(return_value_length
== 0);
2258 test_true(rc
== MEMCACHED_NO_SERVERS
);
2260 for (x
= 0; x
< 3; x
++)
2262 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2263 keys
[x
], key_length
[x
],
2264 (time_t)50, (uint32_t)9);
2265 test_true(rc
== MEMCACHED_NO_SERVERS
);
2268 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2269 test_true(rc
== MEMCACHED_NO_SERVERS
);
2272 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2273 &return_value_length
, &flags
, &rc
)))
2275 test_true(return_value
);
2276 test_true(rc
== MEMCACHED_SUCCESS
);
2277 test_true(return_key_length
== return_value_length
);
2278 test_true(!memcmp(return_value
, return_key
, return_value_length
));
2283 return TEST_SUCCESS
;
2286 #define VALUE_SIZE_BUG5 1048064
2287 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2289 memcached_return_t rc
;
2290 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2291 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2292 char return_key
[MEMCACHED_MAX_KEY
];
2293 size_t return_key_length
;
2295 size_t value_length
;
2299 char insert_data
[VALUE_SIZE_BUG5
];
2301 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2302 insert_data
[x
]= (signed char)rand();
2304 memcached_flush(memc
, 0);
2305 value
= memcached_get(memc
, keys
[0], key_length
[0],
2306 &value_length
, &flags
, &rc
);
2307 test_true(value
== NULL
);
2308 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2311 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2312 &value_length
, &flags
, &rc
)))
2314 test_true(count
== 0);
2316 for (x
= 0; x
< 4; x
++)
2318 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2319 insert_data
, VALUE_SIZE_BUG5
,
2320 (time_t)0, (uint32_t)0);
2321 test_true(rc
== MEMCACHED_SUCCESS
);
2324 for (x
= 0; x
< 10; x
++)
2326 value
= memcached_get(memc
, keys
[0], key_length
[0],
2327 &value_length
, &flags
, &rc
);
2331 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2333 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2334 &value_length
, &flags
, &rc
)))
2339 test_true(count
== 4);
2342 return TEST_SUCCESS
;
2345 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2347 memcached_return_t rc
;
2348 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2349 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2350 char return_key
[MEMCACHED_MAX_KEY
];
2351 size_t return_key_length
;
2353 size_t value_length
;
2357 char insert_data
[VALUE_SIZE_BUG5
];
2359 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2360 insert_data
[x
]= (signed char)rand();
2362 memcached_flush(memc
, 0);
2363 value
= memcached_get(memc
, keys
[0], key_length
[0],
2364 &value_length
, &flags
, &rc
);
2365 test_true(value
== NULL
);
2366 test_true(rc
== MEMCACHED_NOTFOUND
);
2367 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2368 test_true(rc
== MEMCACHED_SUCCESS
);
2371 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2372 &value_length
, &flags
, &rc
)))
2374 test_true(count
== 0);
2375 test_true(rc
== MEMCACHED_END
);
2377 for (x
= 0; x
< 4; x
++)
2379 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2380 insert_data
, VALUE_SIZE_BUG5
,
2381 (time_t)0, (uint32_t)0);
2382 test_true(rc
== MEMCACHED_SUCCESS
);
2385 for (x
= 0; x
< 2; x
++)
2387 value
= memcached_get(memc
, keys
[0], key_length
[0],
2388 &value_length
, &flags
, &rc
);
2392 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2393 test_true(rc
== MEMCACHED_SUCCESS
);
2395 /* We test for purge of partial complete fetches */
2396 for (count
= 3; count
; count
--)
2398 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2399 &value_length
, &flags
, &rc
);
2400 test_true(rc
== MEMCACHED_SUCCESS
);
2401 test_true(!(memcmp(value
, insert_data
, value_length
)));
2402 test_true(value_length
);
2407 return TEST_SUCCESS
;
2410 static test_return_t
user_supplied_bug8(memcached_st
*memc
__attribute__((unused
)))
2412 memcached_return_t rc
;
2414 memcached_st
*memc_clone
;
2416 memcached_server_st
*servers
;
2417 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";
2419 servers
= memcached_servers_parse(server_list
);
2422 mine
= memcached_create(NULL
);
2423 rc
= memcached_server_push(mine
, servers
);
2424 test_true(rc
== MEMCACHED_SUCCESS
);
2425 memcached_server_list_free(servers
);
2428 memc_clone
= memcached_clone(NULL
, mine
);
2430 memcached_quit(mine
);
2431 memcached_quit(memc_clone
);
2434 memcached_free(mine
);
2435 memcached_free(memc_clone
);
2437 return TEST_SUCCESS
;
2440 /* Test flag store/retrieve */
2441 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2443 memcached_return_t rc
;
2444 const char *keys
= "036790384900";
2445 size_t key_length
= strlen(keys
);
2446 char return_key
[MEMCACHED_MAX_KEY
];
2447 size_t return_key_length
;
2449 size_t value_length
;
2452 char insert_data
[VALUE_SIZE_BUG5
];
2454 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2455 insert_data
[x
]= (signed char)rand();
2457 memcached_flush(memc
, 0);
2460 rc
= memcached_set(memc
, keys
, key_length
,
2461 insert_data
, VALUE_SIZE_BUG5
,
2463 test_true(rc
== MEMCACHED_SUCCESS
);
2466 value
= memcached_get(memc
, keys
, key_length
,
2467 &value_length
, &flags
, &rc
);
2468 test_true(flags
== 245);
2472 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2475 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2476 &value_length
, &flags
, &rc
);
2477 test_true(flags
== 245);
2482 return TEST_SUCCESS
;
2485 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2487 memcached_return_t rc
;
2488 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2489 size_t key_length
[3];
2494 char return_key
[MEMCACHED_MAX_KEY
];
2495 size_t return_key_length
;
2497 size_t return_value_length
;
2500 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2501 key_length
[1]= strlen("fudge&*@#");
2502 key_length
[2]= strlen("for^#@&$not");
2505 for (x
= 0; x
< 3; x
++)
2507 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2508 keys
[x
], key_length
[x
],
2509 (time_t)50, (uint32_t)9);
2510 test_true(rc
== MEMCACHED_SUCCESS
);
2513 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2514 test_true(rc
== MEMCACHED_SUCCESS
);
2516 /* We need to empty the server before continueing test */
2517 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2518 &return_value_length
, &flags
, &rc
)) != NULL
)
2520 test_true(return_value
);
2524 test_true(count
== 3);
2526 return TEST_SUCCESS
;
2529 /* We are testing with aggressive timeout to get failures */
2530 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2532 const char *key
= "foo";
2534 size_t value_length
= 512;
2537 memcached_return_t rc
;
2538 unsigned int set
= 1;
2539 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2542 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2543 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2545 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2548 value
= (char*)malloc(value_length
* sizeof(char));
2550 for (x
= 0; x
< value_length
; x
++)
2551 value
[x
]= (char) (x
% 127);
2553 for (x
= 1; x
<= 100000; ++x
)
2555 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2557 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2558 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2560 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2565 memcached_free(mclone
);
2567 return TEST_SUCCESS
;
2571 We are looking failures in the async protocol
2573 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2575 const char *key
= "foo";
2577 size_t value_length
= 512;
2580 memcached_return_t rc
;
2581 unsigned int set
= 1;
2583 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2585 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2586 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2588 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2591 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2593 test_true(timeout
== -1);
2595 value
= (char*)malloc(value_length
* sizeof(char));
2597 for (x
= 0; x
< value_length
; x
++)
2598 value
[x
]= (char) (x
% 127);
2600 for (x
= 1; x
<= 100000; ++x
)
2602 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2606 memcached_free(mclone
);
2608 return TEST_SUCCESS
;
2612 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2614 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2616 memcached_return_t rc
;
2618 size_t value_length
;
2620 uint64_t number_value
;
2622 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2623 &value_length
, &flags
, &rc
);
2624 test_true(value
== NULL
);
2625 test_true(rc
== MEMCACHED_NOTFOUND
);
2627 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2630 test_true(value
== NULL
);
2631 /* The binary protocol will set the key if it doesn't exist */
2632 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2634 test_true(rc
== MEMCACHED_SUCCESS
);
2638 test_true(rc
== MEMCACHED_NOTFOUND
);
2641 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2643 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2644 &value_length
, &flags
, &rc
);
2646 test_true(rc
== MEMCACHED_SUCCESS
);
2649 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2651 test_true(number_value
== 2);
2652 test_true(rc
== MEMCACHED_SUCCESS
);
2654 return TEST_SUCCESS
;
2658 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2659 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2661 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2663 char key
[] = "key34567890";
2665 memcached_return_t rc
;
2666 size_t overflowSize
;
2668 char commandFirst
[]= "set key34567890 0 0 ";
2669 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2670 size_t commandLength
;
2673 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2675 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2677 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2679 overflow
= malloc(testSize
);
2680 test_true(overflow
!= NULL
);
2682 memset(overflow
, 'x', testSize
);
2683 rc
= memcached_set(memc
, key
, strlen(key
),
2684 overflow
, testSize
, 0, 0);
2685 test_true(rc
== MEMCACHED_SUCCESS
);
2689 return TEST_SUCCESS
;
2694 Test values of many different sizes
2695 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2696 set key34567890 0 0 8169 \r\n
2697 is sent followed by buffer of size 8169, followed by 8169
2699 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2702 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2703 memcached_return_t rc
;
2704 const char *key
= "foo";
2706 size_t value_length
= 18000;
2708 size_t string_length
;
2711 size_t current_length
;
2713 value
= (char*)malloc(value_length
);
2716 for (x
= 0; x
< value_length
; x
++)
2717 value
[x
] = (char) (x
% 127);
2719 for (current_length
= 0; current_length
< value_length
; current_length
++)
2721 rc
= memcached_set(memc
, key
, strlen(key
),
2722 value
, current_length
,
2723 (time_t)0, (uint32_t)0);
2724 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2726 string
= memcached_get(memc
, key
, strlen(key
),
2727 &string_length
, &flags
, &rc
);
2729 test_true(rc
== MEMCACHED_SUCCESS
);
2730 test_true(string_length
== current_length
);
2731 test_true(!memcmp(string
, value
, string_length
));
2738 return TEST_SUCCESS
;
2742 Look for zero length value problems
2744 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2747 memcached_return_t rc
;
2748 const char *key
= "mykey";
2753 for (x
= 0; x
< 2; x
++)
2755 rc
= memcached_set(memc
, key
, strlen(key
),
2757 (time_t)0, (uint32_t)0);
2759 test_true(rc
== MEMCACHED_SUCCESS
);
2761 value
= memcached_get(memc
, key
, strlen(key
),
2762 &length
, &flags
, &rc
);
2764 test_true(rc
== MEMCACHED_SUCCESS
);
2765 test_true(value
== NULL
);
2766 test_true(length
== 0);
2767 test_true(flags
== 0);
2769 value
= memcached_get(memc
, key
, strlen(key
),
2770 &length
, &flags
, &rc
);
2772 test_true(rc
== MEMCACHED_SUCCESS
);
2773 test_true(value
== NULL
);
2774 test_true(length
== 0);
2775 test_true(flags
== 0);
2778 return TEST_SUCCESS
;
2781 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2782 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2784 memcached_return_t rc
;
2785 const char *key
= "mykey";
2790 rc
= memcached_set(memc
, key
, strlen(key
),
2792 (time_t)0, UINT32_MAX
);
2794 test_true(rc
== MEMCACHED_SUCCESS
);
2796 value
= memcached_get(memc
, key
, strlen(key
),
2797 &length
, &flags
, &rc
);
2799 test_true(rc
== MEMCACHED_SUCCESS
);
2800 test_true(value
== NULL
);
2801 test_true(length
== 0);
2802 test_true(flags
== UINT32_MAX
);
2804 return TEST_SUCCESS
;
2807 #if !defined(__sun) && !defined(__OpenBSD__)
2808 /* Check the validity of chinese key*/
2809 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2811 memcached_return_t rc
;
2812 const char *key
= "豆瓣";
2813 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2818 rc
= memcached_set(memc
, key
, strlen(key
),
2819 value
, strlen(value
),
2822 test_true(rc
== MEMCACHED_SUCCESS
);
2824 value2
= memcached_get(memc
, key
, strlen(key
),
2825 &length
, &flags
, &rc
);
2827 test_true(length
==strlen(value
));
2828 test_true(rc
== MEMCACHED_SUCCESS
);
2829 test_true(memcmp(value
, value2
, length
)==0);
2832 return TEST_SUCCESS
;
2840 static test_return_t
user_supplied_bug19(memcached_st
*not_used
)
2843 const memcached_server_st
*server
;
2844 memcached_return_t res
;
2848 memc
= memcached_create(NULL
);
2849 memcached_server_add_with_weight(memc
, "localhost", 11311, 100);
2850 memcached_server_add_with_weight(memc
, "localhost", 11312, 100);
2852 server
= memcached_server_by_key(memc
, "a", 1, &res
);
2854 memcached_free(memc
);
2856 return TEST_SUCCESS
;
2859 /* CAS test from Andei */
2860 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2862 memcached_return_t status
;
2863 memcached_result_st
*result
, result_obj
;
2864 const char *key
= "abc";
2865 size_t key_len
= strlen("abc");
2866 const char *value
= "foobar";
2867 size_t value_len
= strlen(value
);
2869 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2871 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2872 test_true(status
== MEMCACHED_SUCCESS
);
2874 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2875 test_true(status
== MEMCACHED_SUCCESS
);
2877 result
= memcached_result_create(memc
, &result_obj
);
2880 memcached_result_create(memc
, &result_obj
);
2881 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2884 test_true(status
== MEMCACHED_SUCCESS
);
2886 memcached_result_free(result
);
2888 return TEST_SUCCESS
;
2891 #include "ketama_test_cases.h"
2892 static test_return_t
user_supplied_bug18(memcached_st
*trash
)
2894 memcached_return_t rc
;
2897 memcached_server_st
*server_pool
;
2902 memc
= memcached_create(NULL
);
2905 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2906 test_true(rc
== MEMCACHED_SUCCESS
);
2908 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2909 test_true(value
== 1);
2911 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2912 test_true(rc
== MEMCACHED_SUCCESS
);
2914 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2915 test_true(value
== MEMCACHED_HASH_MD5
);
2917 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");
2918 memcached_server_push(memc
, server_pool
);
2920 /* verify that the server list was parsed okay. */
2921 test_true(memcached_server_count(memc
) == 8);
2922 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2923 test_true(server_pool
[0].port
== 11211);
2924 test_true(server_pool
[0].weight
== 600);
2925 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2926 test_true(server_pool
[2].port
== 11211);
2927 test_true(server_pool
[2].weight
== 200);
2928 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2929 test_true(server_pool
[7].port
== 11211);
2930 test_true(server_pool
[7].weight
== 100);
2932 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2933 * us test the boundary wraparound.
2935 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
2937 /* verify the standard ketama set. */
2938 for (x
= 0; x
< 99; x
++)
2940 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2942 memcached_server_instance_st instance
=
2943 memcached_server_instance_by_position(memc
, server_idx
);
2945 const char *hostname
= memcached_server_name(instance
);
2946 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
2949 memcached_server_list_free(server_pool
);
2950 memcached_free(memc
);
2952 return TEST_SUCCESS
;
2955 /* Large mget() of missing keys with binary proto
2957 * If many binary quiet commands (such as getq's in an mget) fill the output
2958 * buffer and the server chooses not to respond, memcached_flush hangs. See
2959 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2962 /* sighandler_t function that always asserts false */
2963 static void fail(int unused
__attribute__((unused
)))
2969 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2974 return TEST_SKIPPED
;
2976 memcached_return_t rc
;
2979 size_t* key_lengths
;
2980 void (*oldalarm
)(int);
2981 memcached_st
*memc_clone
;
2983 memc_clone
= memcached_clone(NULL
, memc
);
2984 test_true(memc_clone
);
2986 /* only binproto uses getq for mget */
2987 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2989 /* empty the cache to ensure misses (hence non-responses) */
2990 rc
= memcached_flush(memc_clone
, 0);
2991 test_true(rc
== MEMCACHED_SUCCESS
);
2993 key_lengths
= calloc(key_count
, sizeof(size_t));
2994 keys
= calloc(key_count
, sizeof(char *));
2996 for (x
= 0; x
< key_count
; x
++)
3000 snprintf(buffer
, 30, "%u", x
);
3001 keys
[x
]= strdup(buffer
);
3002 key_lengths
[x
]= strlen(keys
[x
]);
3005 oldalarm
= signal(SIGALRM
, fail
);
3008 rc
= memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
);
3009 test_true(rc
== MEMCACHED_SUCCESS
);
3012 signal(SIGALRM
, oldalarm
);
3014 size_t keys_returned
;
3015 test_true(fetch_all_results(memc
, &keys_returned
) == TEST_SUCCESS
);
3017 for (x
= 0; x
< key_count
; x
++)
3022 memcached_free(memc_clone
);
3024 return TEST_SUCCESS
;
3028 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3030 test_return_t test_rc
;
3031 test_rc
= pre_binary(memc
);
3033 if (test_rc
!= TEST_SUCCESS
)
3038 /* should work as of r580 */
3039 rc
= _user_supplied_bug21(memc
, 10);
3040 test_true(rc
== TEST_SUCCESS
);
3042 /* should fail as of r580 */
3043 rc
= _user_supplied_bug21(memc
, 1000);
3044 test_true(rc
== TEST_SUCCESS
);
3046 return TEST_SUCCESS
;
3049 static test_return_t
auto_eject_hosts(memcached_st
*trash
)
3052 memcached_server_instance_st instance
;
3054 memcached_return_t rc
;
3055 memcached_st
*memc
= memcached_create(NULL
);
3058 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3059 test_true(rc
== MEMCACHED_SUCCESS
);
3061 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3062 test_true(value
== 1);
3064 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3065 test_true(rc
== MEMCACHED_SUCCESS
);
3067 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3068 test_true(value
== MEMCACHED_HASH_MD5
);
3070 /* server should be removed when in delay */
3071 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
3072 test_true(rc
== MEMCACHED_SUCCESS
);
3074 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
3075 test_true(value
== 1);
3077 memcached_server_st
*server_pool
;
3078 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");
3079 memcached_server_push(memc
, server_pool
);
3081 /* verify that the server list was parsed okay. */
3082 test_true(memcached_server_count(memc
) == 8);
3083 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
3084 test_true(server_pool
[0].port
== 11211);
3085 test_true(server_pool
[0].weight
== 600);
3086 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
3087 test_true(server_pool
[2].port
== 11211);
3088 test_true(server_pool
[2].weight
== 200);
3089 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
3090 test_true(server_pool
[7].port
== 11211);
3091 test_true(server_pool
[7].weight
== 100);
3093 instance
= memcached_server_instance_by_position(memc
, 2);
3094 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) + 15;
3095 memc
->next_distribution_rebuild
= time(NULL
) - 1;
3098 This would not work if there were only two hosts.
3100 for (size_t x
= 0; x
< 99; x
++)
3102 memcached_autoeject(memc
);
3103 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3104 test_true(server_idx
!= 2);
3107 /* and re-added when it's back. */
3108 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) - 1;
3109 memc
->next_distribution_rebuild
= time(NULL
) - 1;
3110 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
,
3111 memc
->distribution
);
3112 for (size_t x
= 0; x
< 99; x
++)
3114 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3115 // We re-use instance from above.
3117 memcached_server_instance_by_position(memc
, server_idx
);
3118 const char *hostname
= memcached_server_name(instance
);
3119 test_true(strcmp(hostname
, ketama_test_cases
[x
].server
) == 0);
3122 memcached_server_list_free(server_pool
);
3123 memcached_free(memc
);
3125 return TEST_SUCCESS
;
3128 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
3132 memcached_return_t rc
;
3133 memcached_st
*memc
= memcached_create(NULL
);
3137 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3138 test_true(rc
== MEMCACHED_SUCCESS
);
3140 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3141 test_true(value
== 1);
3143 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3144 test_true(rc
== MEMCACHED_SUCCESS
);
3146 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3147 test_true(value
== MEMCACHED_HASH_MD5
);
3150 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3152 memcached_server_st
*server_pool
;
3153 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");
3154 memcached_server_push(memc
, server_pool
);
3156 // @todo this needs to be refactored to actually test something.
3159 if ((fp
= fopen("ketama_keys.txt", "w")))
3163 printf("cannot write to file ketama_keys.txt");
3164 return TEST_FAILURE
;
3167 for (int x
= 0; x
< 10000; x
++)
3170 snprintf(key
, sizeof(key
), "%d", x
);
3172 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3173 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3174 in_port_t port
= memc
->hosts
[server_idx
].port
;
3175 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3176 memcached_server_instance_st instance
=
3177 memcached_server_instance_by_position(memc
, host_index
);
3181 memcached_server_list_free(server_pool
);
3182 memcached_free(memc
);
3184 return TEST_SUCCESS
;
3188 static test_return_t
result_static(memcached_st
*memc
)
3190 memcached_result_st result
;
3191 memcached_result_st
*result_ptr
;
3193 result_ptr
= memcached_result_create(memc
, &result
);
3194 test_true(result
.options
.is_allocated
== false);
3195 test_true(memcached_is_initialized(&result
) == true);
3196 test_true(result_ptr
);
3197 test_true(result_ptr
== &result
);
3199 memcached_result_free(&result
);
3201 test_true(result
.options
.is_allocated
== false);
3202 test_true(memcached_is_initialized(&result
) == false);
3204 return TEST_SUCCESS
;
3207 static test_return_t
result_alloc(memcached_st
*memc
)
3209 memcached_result_st
*result_ptr
;
3211 result_ptr
= memcached_result_create(memc
, NULL
);
3212 test_true(result_ptr
);
3213 test_true(result_ptr
->options
.is_allocated
== true);
3214 test_true(memcached_is_initialized(result_ptr
) == true);
3215 memcached_result_free(result_ptr
);
3217 return TEST_SUCCESS
;
3220 static test_return_t
string_static_null(memcached_st
*memc
)
3222 memcached_string_st string
;
3223 memcached_string_st
*string_ptr
;
3225 string_ptr
= memcached_string_create(memc
, &string
, 0);
3226 test_true(string
.options
.is_initialized
== true);
3227 test_true(string_ptr
);
3229 /* The following two better be the same! */
3230 test_true(memcached_is_allocated(string_ptr
) == false);
3231 test_true(memcached_is_allocated(&string
) == false);
3232 test_true(&string
== string_ptr
);
3234 test_true(string
.options
.is_initialized
== true);
3235 test_true(memcached_is_initialized(&string
) == true);
3236 memcached_string_free(&string
);
3237 test_true(memcached_is_initialized(&string
) == false);
3239 return TEST_SUCCESS
;
3242 static test_return_t
string_alloc_null(memcached_st
*memc
)
3244 memcached_string_st
*string
;
3246 string
= memcached_string_create(memc
, NULL
, 0);
3248 test_true(memcached_is_allocated(string
) == true);
3249 test_true(memcached_is_initialized(string
) == true);
3250 memcached_string_free(string
);
3252 return TEST_SUCCESS
;
3255 static test_return_t
string_alloc_with_size(memcached_st
*memc
)
3257 memcached_string_st
*string
;
3259 string
= memcached_string_create(memc
, NULL
, 1024);
3261 test_true(memcached_is_allocated(string
) == true);
3262 test_true(memcached_is_initialized(string
) == true);
3263 memcached_string_free(string
);
3265 return TEST_SUCCESS
;
3268 static test_return_t
string_alloc_with_size_toobig(memcached_st
*memc
)
3270 memcached_string_st
*string
;
3272 string
= memcached_string_create(memc
, NULL
, SIZE_MAX
);
3273 test_true(string
== NULL
);
3275 return TEST_SUCCESS
;
3278 static test_return_t
string_alloc_append(memcached_st
*memc
)
3281 char buffer
[SMALL_STRING_LEN
];
3282 memcached_string_st
*string
;
3284 /* Ring the bell! */
3285 memset(buffer
, 6, SMALL_STRING_LEN
);
3287 string
= memcached_string_create(memc
, NULL
, 100);
3289 test_true(memcached_is_allocated(string
) == true);
3290 test_true(memcached_is_initialized(string
) == true);
3292 for (x
= 0; x
< 1024; x
++)
3294 memcached_return_t rc
;
3295 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
3296 test_true(rc
== MEMCACHED_SUCCESS
);
3298 test_true(memcached_is_allocated(string
) == true);
3299 memcached_string_free(string
);
3301 return TEST_SUCCESS
;
3304 static test_return_t
string_alloc_append_toobig(memcached_st
*memc
)
3306 memcached_return_t rc
;
3308 char buffer
[SMALL_STRING_LEN
];
3309 memcached_string_st
*string
;
3311 /* Ring the bell! */
3312 memset(buffer
, 6, SMALL_STRING_LEN
);
3314 string
= memcached_string_create(memc
, NULL
, 100);
3316 test_true(memcached_is_allocated(string
) == true);
3317 test_true(memcached_is_initialized(string
) == true);
3319 for (x
= 0; x
< 1024; x
++)
3321 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
3322 test_true(rc
== MEMCACHED_SUCCESS
);
3324 rc
= memcached_string_append(string
, buffer
, SIZE_MAX
);
3325 test_true(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
3326 test_true(memcached_is_allocated(string
) == true);
3327 memcached_string_free(string
);
3329 return TEST_SUCCESS
;
3332 static test_return_t
cleanup_pairs(memcached_st
*memc
__attribute__((unused
)))
3334 pairs_free(global_pairs
);
3336 return TEST_SUCCESS
;
3339 static test_return_t
generate_pairs(memcached_st
*memc
__attribute__((unused
)))
3341 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3342 global_count
= GLOBAL_COUNT
;
3344 for (size_t x
= 0; x
< global_count
; x
++)
3346 global_keys
[x
]= global_pairs
[x
].key
;
3347 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3350 return TEST_SUCCESS
;
3353 static test_return_t
generate_large_pairs(memcached_st
*memc
__attribute__((unused
)))
3355 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3356 global_count
= GLOBAL2_COUNT
;
3358 for (size_t x
= 0; x
< global_count
; x
++)
3360 global_keys
[x
]= global_pairs
[x
].key
;
3361 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3364 return TEST_SUCCESS
;
3367 static test_return_t
generate_data(memcached_st
*memc
)
3369 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3371 test_true(check_execute
== global_count
);
3373 return TEST_SUCCESS
;
3376 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3378 memcached_stat_st
*stat_p
;
3379 memcached_return_t rc
;
3380 uint32_t host_index
= 0;
3381 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3383 test_true(check_execute
== global_count
);
3385 //TODO: hosts used size stats
3386 stat_p
= memcached_stat(memc
, NULL
, &rc
);
3389 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3391 /* This test was changes so that "make test" would work properlly */
3393 memcached_server_instance_st instance
=
3394 memcached_server_instance_by_position(memc
, host_index
);
3396 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3398 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3401 memcached_stat_free(NULL
, stat_p
);
3403 return TEST_SUCCESS
;
3405 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3410 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3411 generate_data(memc
);
3413 return TEST_SUCCESS
;
3416 static test_return_t
get_read_count(memcached_st
*memc
)
3418 memcached_return_t rc
;
3419 memcached_st
*memc_clone
;
3421 memc_clone
= memcached_clone(NULL
, memc
);
3422 test_true(memc_clone
);
3424 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3428 size_t return_value_length
;
3432 for (size_t x
= count
= 0; x
< global_count
; x
++)
3434 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3435 &return_value_length
, &flags
, &rc
);
3436 if (rc
== MEMCACHED_SUCCESS
)
3445 memcached_free(memc_clone
);
3447 return TEST_SUCCESS
;
3450 static test_return_t
get_read(memcached_st
*memc
)
3452 memcached_return_t rc
;
3456 size_t return_value_length
;
3459 for (size_t x
= 0; x
< global_count
; x
++)
3461 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3462 &return_value_length
, &flags
, &rc
);
3464 test_true(return_value);
3465 test_true(rc == MEMCACHED_SUCCESS);
3467 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3472 return TEST_SUCCESS
;
3475 static test_return_t
mget_read(memcached_st
*memc
)
3477 memcached_return_t rc
;
3479 if (! libmemcached_util_version_check(memc
, 1, 4, 4))
3480 return TEST_SKIPPED
;
3482 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3484 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
3486 // Go fetch the keys and test to see if all of them were returned
3488 size_t keys_returned
;
3489 test_true(fetch_all_results(memc
, &keys_returned
) == TEST_SUCCESS
);
3491 snprintf(buffer
, sizeof(buffer
), "%lu", (unsigned long)keys_returned
);
3492 test_true_got(global_count
== keys_returned
, buffer
);
3496 return TEST_SUCCESS
;
3499 static test_return_t
mget_read_result(memcached_st
*memc
)
3501 memcached_return_t rc
;
3503 if (! libmemcached_util_version_check(memc
, 1, 4, 4))
3504 return TEST_SKIPPED
;
3506 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3508 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
3510 /* Turn this into a help function */
3512 memcached_result_st results_obj
;
3513 memcached_result_st
*results
;
3515 results
= memcached_result_create(memc
, &results_obj
);
3517 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3520 test_true(rc
== MEMCACHED_SUCCESS
);
3523 memcached_result_free(&results_obj
);
3526 return TEST_SUCCESS
;
3529 static test_return_t
mget_read_function(memcached_st
*memc
)
3531 memcached_return_t rc
;
3533 memcached_execute_fn callbacks
[1];
3535 if (! libmemcached_util_version_check(memc
, 1, 4, 4))
3536 return TEST_SKIPPED
;
3538 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3540 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
3542 callbacks
[0]= &callback_counter
;
3544 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
3546 return TEST_SUCCESS
;
3549 static test_return_t
delete_generate(memcached_st
*memc
)
3551 for (size_t x
= 0; x
< global_count
; x
++)
3553 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3556 return TEST_SUCCESS
;
3559 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3564 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3566 for (size_t x
= 0; x
< global_count
; x
++)
3568 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3571 return TEST_SUCCESS
;
3574 static test_return_t
add_host_test1(memcached_st
*memc
)
3576 memcached_return_t rc
;
3577 char servername
[]= "0.example.com";
3578 memcached_server_st
*servers
;
3580 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3582 test_true(1 == memcached_server_list_count(servers
));
3584 for (size_t x
= 2; x
< 20; x
++)
3586 char buffer
[SMALL_STRING_LEN
];
3588 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3589 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3591 test_true(rc
== MEMCACHED_SUCCESS
);
3592 test_true(x
== memcached_server_list_count(servers
));
3595 rc
= memcached_server_push(memc
, servers
);
3596 test_true(rc
== MEMCACHED_SUCCESS
);
3597 rc
= memcached_server_push(memc
, servers
);
3598 test_true(rc
== MEMCACHED_SUCCESS
);
3600 memcached_server_list_free(servers
);
3602 return TEST_SUCCESS
;
3605 static test_return_t
pre_nonblock(memcached_st
*memc
)
3607 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3609 return TEST_SUCCESS
;
3612 static test_return_t
pre_cork(memcached_st
*memc
)
3614 memcached_return_t rc
;
3617 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
3620 return TEST_SKIPPED
;
3623 if (rc
== MEMCACHED_SUCCESS
)
3624 return TEST_SUCCESS
;
3626 return TEST_SKIPPED
;
3629 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3636 return TEST_SKIPPED
;
3639 if (rc
!= TEST_SUCCESS
)
3642 return pre_nonblock(memc
);
3645 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3647 memcached_return_t rc
= MEMCACHED_FAILURE
;
3648 memcached_st
*memc_clone
;
3650 memc_clone
= memcached_clone(NULL
, memc
);
3651 test_true(memc_clone
);
3652 // The memcached_version needs to be done on a clone, because the server
3653 // will not toggle protocol on an connection.
3654 memcached_version(memc_clone
);
3656 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3658 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3659 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3660 test_true(rc
== MEMCACHED_SUCCESS
);
3661 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3665 return TEST_SKIPPED
;
3668 memcached_free(memc_clone
);
3670 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3673 static test_return_t
pre_murmur(memcached_st
*memc
)
3675 #ifdef HAVE_MURMUR_HASH
3676 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3677 return TEST_SUCCESS
;
3680 return TEST_SKIPPED
;
3684 static test_return_t
pre_jenkins(memcached_st
*memc
)
3686 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3688 return TEST_SUCCESS
;
3692 static test_return_t
pre_md5(memcached_st
*memc
)
3694 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3696 return TEST_SUCCESS
;
3699 static test_return_t
pre_crc(memcached_st
*memc
)
3701 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3703 return TEST_SUCCESS
;
3706 static test_return_t
pre_hsieh(memcached_st
*memc
)
3708 #ifdef HAVE_HSIEH_HASH
3709 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3710 return TEST_SUCCESS
;
3713 return TEST_SKIPPED
;
3717 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3719 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3721 return TEST_SUCCESS
;
3724 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3726 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3728 return TEST_SUCCESS
;
3731 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3733 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3735 return TEST_SUCCESS
;
3738 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3740 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3742 return TEST_SUCCESS
;
3745 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3747 memcached_return_t rc
;
3750 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3751 test_true(rc
== MEMCACHED_SUCCESS
);
3753 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3754 test_true(value
== 1);
3756 return TEST_SUCCESS
;
3759 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3761 memcached_return_t rc
;
3764 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3765 test_true(rc
== MEMCACHED_SUCCESS
);
3767 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3768 test_true(value
== 1);
3770 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3771 test_true(rc
== MEMCACHED_SUCCESS
);
3773 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3774 test_true(value
== MEMCACHED_HASH_MD5
);
3776 return TEST_SUCCESS
;
3780 @note This should be testing to see if the server really supports the binary protocol.
3782 static test_return_t
pre_binary(memcached_st
*memc
)
3784 memcached_return_t rc
= MEMCACHED_FAILURE
;
3786 if (libmemcached_util_version_check(memc
, 1, 4, 4))
3788 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3789 test_true(rc
== MEMCACHED_SUCCESS
);
3790 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3793 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3796 static test_return_t
pre_sasl(memcached_st
*memc
)
3798 memcached_return_t rc
= MEMCACHED_FAILURE
;
3800 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
3801 const char *server
= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
3802 const char *user
= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
3803 const char *pass
= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
3805 if (server
!= NULL
&& user
!= NULL
&& pass
!= NULL
)
3807 memcached_server_st
*servers
= memcached_servers_parse(server
);
3808 test_true(servers
!= NULL
);
3809 memcached_servers_reset(memc
);
3810 test_true(memcached_server_push(memc
, servers
) == MEMCACHED_SUCCESS
);
3811 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3812 rc
= memcached_set_sasl_auth_data(memc
, user
, pass
);
3813 test_true(rc
== MEMCACHED_SUCCESS
);
3819 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3822 static test_return_t
pre_replication(memcached_st
*memc
)
3824 test_return_t test_rc
;
3825 test_rc
= pre_binary(memc
);
3827 if (test_rc
!= TEST_SUCCESS
)
3831 * Make sure that we store the item on all servers
3832 * (master + replicas == number of servers)
3834 memcached_return_t rc
;
3835 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3836 memcached_server_count(memc
) - 1);
3837 test_true(rc
== MEMCACHED_SUCCESS
);
3838 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memcached_server_count(memc
) - 1);
3840 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3844 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3848 rc
= pre_replication(memc
);
3849 if (rc
!= TEST_SUCCESS
)
3852 rc
= pre_nonblock(memc
);
3858 static void my_free(const memcached_st
*ptr
__attribute__((unused
)), void *mem
, void *context
)
3861 #ifdef HARD_MALLOC_TESTS
3862 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3870 static void *my_malloc(const memcached_st
*ptr
__attribute__((unused
)), const size_t size
, void *context
)
3873 #ifdef HARD_MALLOC_TESTS
3874 void *ret
= malloc(size
+ 8);
3877 ret
= (void*)((caddr_t
)ret
+ 8);
3880 void *ret
= malloc(size
);
3885 memset(ret
, 0xff, size
);
3892 static void *my_realloc(const memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
, void *context
)
3895 #ifdef HARD_MALLOC_TESTS
3896 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3897 void *nmem
= realloc(real_ptr
, size
+ 8);
3902 ret
= (void*)((caddr_t
)nmem
+ 8);
3907 return realloc(mem
, size
);
3912 static void *my_calloc(const memcached_st
*ptr
__attribute__((unused
)), size_t nelem
, const size_t size
, void *context
)
3915 #ifdef HARD_MALLOC_TESTS
3916 void *mem
= my_malloc(ptr
, nelem
* size
);
3919 memset(mem
, 0, nelem
* size
);
3924 return calloc(nelem
, size
);
3929 static test_return_t
set_prefix(memcached_st
*memc
)
3931 memcached_return_t rc
;
3932 const char *key
= "mine";
3935 /* Make sure be default none exists */
3936 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3937 test_true(rc
== MEMCACHED_FAILURE
);
3939 /* Test a clean set */
3940 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3941 test_true(rc
== MEMCACHED_SUCCESS
);
3943 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3944 test_true(memcmp(value
, key
, 4) == 0);
3945 test_true(rc
== MEMCACHED_SUCCESS
);
3947 /* Test that we can turn it off */
3948 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3949 test_true(rc
== MEMCACHED_SUCCESS
);
3951 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3952 test_true(rc
== MEMCACHED_FAILURE
);
3954 /* Now setup for main test */
3955 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3956 test_true(rc
== MEMCACHED_SUCCESS
);
3958 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3959 test_true(rc
== MEMCACHED_SUCCESS
);
3960 test_true(memcmp(value
, key
, 4) == 0);
3962 /* Set to Zero, and then Set to something too large */
3965 memset(long_key
, 0, 255);
3967 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3968 test_true(rc
== MEMCACHED_SUCCESS
);
3970 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3971 test_true(rc
== MEMCACHED_FAILURE
);
3972 test_true(value
== NULL
);
3974 /* Test a long key for failure */
3975 /* TODO, extend test to determine based on setting, what result should be */
3976 strcpy(long_key
, "Thisismorethentheallottednumberofcharacters");
3977 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3978 //test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3979 test_true(rc
== MEMCACHED_SUCCESS
);
3981 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3982 strcpy(long_key
, "This is more then the allotted number of characters");
3983 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3984 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3986 /* Test for a bad prefix, but with a short key */
3987 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3988 test_true(rc
== MEMCACHED_SUCCESS
);
3990 strcpy(long_key
, "dog cat");
3991 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3992 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3995 return TEST_SUCCESS
;
3999 #ifdef MEMCACHED_ENABLE_DEPRECATED
4000 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
4002 void *test_ptr
= NULL
;
4005 memcached_malloc_fn malloc_cb
=
4006 (memcached_malloc_fn
)my_malloc
;
4007 cb_ptr
= *(void **)&malloc_cb
;
4008 memcached_return_t rc
;
4010 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
4011 test_true(rc
== MEMCACHED_SUCCESS
);
4012 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
4013 test_true(rc
== MEMCACHED_SUCCESS
);
4014 test_true(test_ptr
== cb_ptr
);
4018 memcached_realloc_fn realloc_cb
=
4019 (memcached_realloc_fn
)my_realloc
;
4020 cb_ptr
= *(void **)&realloc_cb
;
4021 memcached_return_t rc
;
4023 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
4024 test_true(rc
== MEMCACHED_SUCCESS
);
4025 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
4026 test_true(rc
== MEMCACHED_SUCCESS
);
4027 test_true(test_ptr
== cb_ptr
);
4031 memcached_free_fn free_cb
=
4032 (memcached_free_fn
)my_free
;
4033 cb_ptr
= *(void **)&free_cb
;
4034 memcached_return_t rc
;
4036 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
4037 test_true(rc
== MEMCACHED_SUCCESS
);
4038 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
4039 test_true(rc
== MEMCACHED_SUCCESS
);
4040 test_true(test_ptr
== cb_ptr
);
4043 return TEST_SUCCESS
;
4048 static test_return_t
set_memory_alloc(memcached_st
*memc
)
4050 memcached_return_t rc
;
4051 rc
= memcached_set_memory_allocators(memc
, NULL
, my_free
,
4052 my_realloc
, my_calloc
, NULL
);
4053 test_true(rc
== MEMCACHED_FAILURE
);
4055 rc
= memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
4056 my_realloc
, my_calloc
, NULL
);
4058 memcached_malloc_fn mem_malloc
;
4059 memcached_free_fn mem_free
;
4060 memcached_realloc_fn mem_realloc
;
4061 memcached_calloc_fn mem_calloc
;
4062 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
4063 &mem_realloc
, &mem_calloc
);
4065 test_true(mem_malloc
== my_malloc
);
4066 test_true(mem_realloc
== my_realloc
);
4067 test_true(mem_calloc
== my_calloc
);
4068 test_true(mem_free
== my_free
);
4070 return TEST_SUCCESS
;
4073 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
4076 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4077 memcached_hash_t hash
;
4078 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4079 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
4082 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4083 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4085 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4087 if (hash
!= MEMCACHED_HASH_CRC
)
4088 return TEST_SKIPPED
;
4090 return TEST_SUCCESS
;
4093 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
4096 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4097 memcached_hash_t hash
;
4098 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4099 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
4102 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4103 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4105 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4107 if (hash
!= MEMCACHED_HASH_HSIEH
)
4108 return TEST_SKIPPED
;
4111 return TEST_SUCCESS
;
4114 static test_return_t
enable_cas(memcached_st
*memc
)
4116 unsigned int set
= 1;
4118 if (libmemcached_util_version_check(memc
, 1, 2, 4))
4120 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
4122 return TEST_SUCCESS
;
4125 return TEST_SKIPPED
;
4128 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
4130 memcached_version(memc
);
4132 memcached_server_instance_st instance
=
4133 memcached_server_instance_by_position(memc
, 0);
4135 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
4136 || instance
->minor_version
> 2)
4138 return TEST_SUCCESS
;
4141 return TEST_SKIPPED
;
4144 static test_return_t
pre_unix_socket(memcached_st
*memc
)
4146 memcached_return_t rc
;
4149 memcached_servers_reset(memc
);
4151 if (stat("/tmp/memcached.socket", &buf
))
4152 return TEST_SKIPPED
;
4154 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
4156 return ( rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_FAILURE
);
4159 static test_return_t
pre_nodelay(memcached_st
*memc
)
4161 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
4162 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
4164 return TEST_SUCCESS
;
4167 static test_return_t
pre_settimer(memcached_st
*memc
)
4169 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4170 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4172 return TEST_SUCCESS
;
4175 static test_return_t
poll_timeout(memcached_st
*memc
)
4181 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4183 timeout
= (size_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
4185 test_true(timeout
== 100);
4187 return TEST_SUCCESS
;
4190 static test_return_t
noreply_test(memcached_st
*memc
)
4192 memcached_return_t ret
;
4193 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
4194 test_true(ret
== MEMCACHED_SUCCESS
);
4195 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4196 test_true(ret
== MEMCACHED_SUCCESS
);
4197 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
4198 test_true(ret
== MEMCACHED_SUCCESS
);
4199 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
4200 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
4201 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
4203 for (int count
=0; count
< 5; ++count
)
4205 for (size_t x
= 0; x
< 100; ++x
)
4208 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4209 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4211 size_t len
= (size_t)check_length
;
4216 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4219 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4222 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4225 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4228 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4234 test_true(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
4238 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4239 ** API and is _ONLY_ done this way to verify that the library works the
4240 ** way it is supposed to do!!!!
4243 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4245 memcached_server_instance_st instance
=
4246 memcached_server_instance_by_position(memc
, x
);
4247 no_msg
+=(int)(instance
->cursor_active
);
4250 test_true(no_msg
== 0);
4251 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4254 ** Now validate that all items was set properly!
4256 for (size_t x
= 0; x
< 100; ++x
)
4260 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4262 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4264 size_t len
= (size_t)check_length
;
4267 char* value
=memcached_get(memc
, key
, strlen(key
),
4268 &length
, &flags
, &ret
);
4269 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4272 case 0: /* FALLTHROUGH */
4273 case 1: /* FALLTHROUGH */
4275 test_true(strncmp(value
, key
, len
) == 0);
4276 test_true(len
== length
);
4279 test_true(length
== len
* 2);
4282 test_true(length
== len
* 3);
4292 /* Try setting an illegal cas value (should not return an error to
4293 * the caller (because we don't expect a return message from the server)
4295 const char* keys
[]= {"0"};
4296 size_t lengths
[]= {1};
4299 memcached_result_st results_obj
;
4300 memcached_result_st
*results
;
4301 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4302 test_true(ret
== MEMCACHED_SUCCESS
);
4304 results
= memcached_result_create(memc
, &results_obj
);
4306 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4308 test_true(ret
== MEMCACHED_SUCCESS
);
4309 uint64_t cas
= memcached_result_cas(results
);
4310 memcached_result_free(&results_obj
);
4312 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4313 test_true(ret
== MEMCACHED_SUCCESS
);
4316 * The item will have a new cas value, so try to set it again with the old
4317 * value. This should fail!
4319 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4320 test_true(ret
== MEMCACHED_SUCCESS
);
4321 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4322 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4323 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4326 return TEST_SUCCESS
;
4329 static test_return_t
analyzer_test(memcached_st
*memc
)
4331 memcached_return_t rc
;
4332 memcached_stat_st
*memc_stat
;
4333 memcached_analysis_st
*report
;
4335 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4336 test_true(rc
== MEMCACHED_SUCCESS
);
4337 test_true(memc_stat
);
4339 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4340 test_true(rc
== MEMCACHED_SUCCESS
);
4344 memcached_stat_free(NULL
, memc_stat
);
4346 return TEST_SUCCESS
;
4349 /* Count the objects */
4350 static memcached_return_t
callback_dump_counter(const memcached_st
*ptr
__attribute__((unused
)),
4351 const char *key
__attribute__((unused
)),
4352 size_t key_length
__attribute__((unused
)),
4355 size_t *counter
= (size_t *)context
;
4357 *counter
= *counter
+ 1;
4359 return MEMCACHED_SUCCESS
;
4362 static test_return_t
dump_test(memcached_st
*memc
)
4364 memcached_return_t rc
;
4366 memcached_dump_fn callbacks
[1];
4367 test_return_t main_rc
;
4369 callbacks
[0]= &callback_dump_counter
;
4371 /* No support for Binary protocol yet */
4372 if (memc
->flags
.binary_protocol
)
4373 return TEST_SUCCESS
;
4375 main_rc
= set_test3(memc
);
4377 test_true (main_rc
== TEST_SUCCESS
);
4379 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
4380 test_true(rc
== MEMCACHED_SUCCESS
);
4382 /* We may have more then 32 if our previous flush has not completed */
4383 test_true(counter
>= 32);
4385 return TEST_SUCCESS
;
4388 #ifdef HAVE_LIBMEMCACHEDUTIL
4389 static void* connection_release(void *arg
)
4392 memcached_pool_st
* pool
;
4397 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
4401 #define POOL_SIZE 10
4402 static test_return_t
connection_pool_test(memcached_st
*memc
)
4404 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4405 test_true(pool
!= NULL
);
4406 memcached_st
*mmc
[POOL_SIZE
];
4407 memcached_return_t rc
;
4409 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4411 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4412 test_true(mmc
[x
] != NULL
);
4413 test_true(rc
== MEMCACHED_SUCCESS
);
4416 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4417 test_true(rc
== MEMCACHED_SUCCESS
);
4421 memcached_pool_st
* pool
;
4423 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
4424 pthread_create(&tid
, NULL
, connection_release
, &item
);
4425 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4426 test_true(rc
== MEMCACHED_SUCCESS
);
4427 pthread_join(tid
, NULL
);
4428 test_true(mmc
[9] == item
.mmc
);
4429 const char *key
= "key";
4430 size_t keylen
= strlen(key
);
4432 // verify that I can do ops with all connections
4433 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
4434 test_true(rc
== MEMCACHED_SUCCESS
);
4436 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4438 uint64_t number_value
;
4439 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
4440 test_true(rc
== MEMCACHED_SUCCESS
);
4441 test_true(number_value
== (x
+1));
4445 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4447 test_true(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
4451 /* verify that I can set behaviors on the pool when I don't have all
4452 * of the connections in the pool. It should however be enabled
4453 * when I push the item into the pool
4455 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4456 test_true(mmc
[0] != NULL
);
4458 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4459 test_true(rc
== MEMCACHED_SUCCESS
);
4461 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4462 test_true(mmc
[1] != NULL
);
4464 test_true(memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4465 test_true(memcached_pool_push(pool
, mmc
[1]) == MEMCACHED_SUCCESS
);
4466 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4468 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4469 test_true(memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4470 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4472 test_true(memcached_pool_destroy(pool
) == memc
);
4474 return TEST_SUCCESS
;
4477 static test_return_t
util_version_test(memcached_st
*memc
)
4481 if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4482 test_true(if_successful
== true);
4484 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4486 // We expect failure
4489 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4490 fprintf(stderr
, "\nDumping Server Information\n\n");
4491 memcached_server_fn callbacks
[1];
4493 callbacks
[0]= dump_server_information
;
4494 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4495 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4497 test_true(if_successful
== false);
4499 memcached_server_instance_st instance
=
4500 memcached_server_instance_by_position(memc
, 0);
4502 memcached_version(memc
);
4504 // We only use one binary when we test, so this should be just fine.
4505 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4506 test_true(if_successful
== true);
4508 if (instance
->micro_version
> 0)
4509 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4510 else if (instance
->minor_version
> 0)
4511 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4512 else if (instance
->major_version
> 0)
4513 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4515 test_true(if_successful
== true);
4517 if (instance
->micro_version
> 0)
4518 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4519 else if (instance
->minor_version
> 0)
4520 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4521 else if (instance
->major_version
> 0)
4522 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4524 test_true(if_successful
== false);
4526 return TEST_SUCCESS
;
4529 static test_return_t
ping_test(memcached_st
*memc
)
4531 memcached_return_t rc
;
4532 memcached_server_instance_st instance
=
4533 memcached_server_instance_by_position(memc
, 0);
4535 // Test both the version that returns a code, and the one that does not.
4536 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4537 memcached_server_port(instance
), NULL
));
4539 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4540 memcached_server_port(instance
), &rc
));
4542 test_true(rc
== MEMCACHED_SUCCESS
);
4544 return TEST_SUCCESS
;
4548 static test_return_t
replication_set_test(memcached_st
*memc
)
4550 memcached_return_t rc
;
4551 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4552 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
4554 rc
= memcached_set(memc
, "bubba", 5, "0", 1, 0, 0);
4555 test_true(rc
== MEMCACHED_SUCCESS
);
4558 ** We are using the quiet commands to store the replicas, so we need
4559 ** to ensure that all of them are processed before we can continue.
4560 ** In the test we go directly from storing the object to trying to
4561 ** receive the object from all of the different servers, so we
4562 ** could end up in a race condition (the memcached server hasn't yet
4563 ** processed the quiet command from the replication set when it process
4564 ** the request from the other client (created by the clone)). As a
4565 ** workaround for that we call memcached_quit to send the quit command
4566 ** to the server and wait for the response ;-) If you use the test code
4567 ** as an example for your own code, please note that you shouldn't need
4570 memcached_quit(memc
);
4573 ** "bubba" should now be stored on all of our servers. We don't have an
4574 ** easy to use API to address each individual server, so I'll just iterate
4575 ** through a bunch of "master keys" and I should most likely hit all of the
4578 for (int x
= 'a'; x
<= 'z'; ++x
)
4580 char key
[2]= { [0]= (char)x
};
4583 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
4585 test_true(rc
== MEMCACHED_SUCCESS
);
4586 test_true(val
!= NULL
);
4590 memcached_free(memc_clone
);
4592 return TEST_SUCCESS
;
4595 static test_return_t
replication_get_test(memcached_st
*memc
)
4597 memcached_return_t rc
;
4600 * Don't do the following in your code. I am abusing the internal details
4601 * within the library, and this is not a supported interface.
4602 * This is to verify correct behavior in the library
4604 for (uint32_t host
= 0; host
< memcached_server_count(memc
); ++host
)
4606 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4607 memcached_server_instance_st instance
=
4608 memcached_server_instance_by_position(memc_clone
, host
);
4610 ((memcached_server_write_instance_st
)instance
)->port
= 0;
4612 for (int x
= 'a'; x
<= 'z'; ++x
)
4614 char key
[2]= { [0]= (char)x
};
4617 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
4619 test_true(rc
== MEMCACHED_SUCCESS
);
4620 test_true(val
!= NULL
);
4624 memcached_free(memc_clone
);
4627 return TEST_SUCCESS
;
4630 static test_return_t
replication_mget_test(memcached_st
*memc
)
4632 memcached_return_t rc
;
4633 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4634 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
4636 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
4637 size_t len
[]= { 5, 4, 4, 4 };
4639 for (size_t x
= 0; x
< 4; ++x
)
4641 rc
= memcached_set(memc
, keys
[x
], len
[x
], "0", 1, 0, 0);
4642 test_true(rc
== MEMCACHED_SUCCESS
);
4646 ** We are using the quiet commands to store the replicas, so we need
4647 ** to ensure that all of them are processed before we can continue.
4648 ** In the test we go directly from storing the object to trying to
4649 ** receive the object from all of the different servers, so we
4650 ** could end up in a race condition (the memcached server hasn't yet
4651 ** processed the quiet command from the replication set when it process
4652 ** the request from the other client (created by the clone)). As a
4653 ** workaround for that we call memcached_quit to send the quit command
4654 ** to the server and wait for the response ;-) If you use the test code
4655 ** as an example for your own code, please note that you shouldn't need
4658 memcached_quit(memc
);
4661 * Don't do the following in your code. I am abusing the internal details
4662 * within the library, and this is not a supported interface.
4663 * This is to verify correct behavior in the library
4665 memcached_result_st result_obj
;
4666 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; host
++)
4668 memcached_st
*new_clone
= memcached_clone(NULL
, memc
);
4669 memcached_server_instance_st instance
=
4670 memcached_server_instance_by_position(new_clone
, host
);
4671 ((memcached_server_write_instance_st
)instance
)->port
= 0;
4673 for (int x
= 'a'; x
<= 'z'; ++x
)
4675 char key
[2]= { [0]= (char)x
, [1]= 0 };
4677 rc
= memcached_mget_by_key(new_clone
, key
, 1, keys
, len
, 4);
4678 test_true(rc
== MEMCACHED_SUCCESS
);
4680 memcached_result_st
*results
= memcached_result_create(new_clone
, &result_obj
);
4684 while ((results
= memcached_fetch_result(new_clone
, &result_obj
, &rc
)) != NULL
)
4688 test_true(hits
== 4);
4689 memcached_result_free(&result_obj
);
4692 memcached_free(new_clone
);
4695 memcached_free(memc_clone
);
4697 return TEST_SUCCESS
;
4700 static test_return_t
replication_randomize_mget_test(memcached_st
*memc
)
4702 memcached_result_st result_obj
;
4703 memcached_return_t rc
;
4704 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4705 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 3);
4706 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ
, 1);
4708 const char *keys
[]= { "key1", "key2", "key3", "key4", "key5", "key6", "key7" };
4709 size_t len
[]= { 4, 4, 4, 4, 4, 4, 4 };
4711 for (size_t x
= 0; x
< 7; ++x
)
4713 rc
= memcached_set(memc
, keys
[x
], len
[x
], "1", 1, 0, 0);
4714 test_true(rc
== MEMCACHED_SUCCESS
);
4717 memcached_quit(memc
);
4719 for (size_t x
= 0; x
< 7; ++x
)
4721 const char key
[2]= { [0]= (const char)x
};
4723 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 7);
4724 test_true(rc
== MEMCACHED_SUCCESS
);
4726 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4730 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4734 test_true(hits
== 7);
4735 memcached_result_free(&result_obj
);
4737 memcached_free(memc_clone
);
4738 return TEST_SUCCESS
;
4741 static test_return_t
replication_delete_test(memcached_st
*memc
)
4743 memcached_return_t rc
;
4744 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4745 /* Delete the items from all of the servers except 1 */
4746 uint64_t repl
= memcached_behavior_get(memc
,
4747 MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
4748 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, --repl
);
4750 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
4751 size_t len
[]= { 5, 4, 4, 4 };
4753 for (size_t x
= 0; x
< 4; ++x
)
4755 rc
= memcached_delete_by_key(memc
, keys
[0], len
[0], keys
[x
], len
[x
], 0);
4756 test_true(rc
== MEMCACHED_SUCCESS
);
4760 * Don't do the following in your code. I am abusing the internal details
4761 * within the library, and this is not a supported interface.
4762 * This is to verify correct behavior in the library
4764 uint32_t hash
= memcached_generate_hash(memc
, keys
[0], len
[0]);
4765 for (uint32_t x
= 0; x
< (repl
+ 1); ++x
)
4767 memcached_server_instance_st instance
=
4768 memcached_server_instance_by_position(memc_clone
, x
);
4770 ((memcached_server_write_instance_st
)instance
)->port
= 0;
4771 if (++hash
== memc_clone
->number_of_hosts
)
4775 memcached_result_st result_obj
;
4776 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; ++host
)
4778 for (size_t x
= 'a'; x
<= 'z'; ++x
)
4780 const char key
[2]= { [0]= (const char)x
};
4782 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 4);
4783 test_true(rc
== MEMCACHED_SUCCESS
);
4785 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4789 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4793 test_true(hits
== 4);
4794 memcached_result_free(&result_obj
);
4797 memcached_free(memc_clone
);
4799 return TEST_SUCCESS
;
4803 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4807 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4808 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4809 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4810 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4811 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4812 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4813 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4814 #ifdef HAVE_HSIEH_HASH
4815 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4817 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4818 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4819 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4821 return TEST_SUCCESS
;
4825 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4827 memcached_return_t expected_rc
= MEMCACHED_FAILURE
;
4828 #ifdef HAVE_HSIEH_HASH
4829 expected_rc
= MEMCACHED_SUCCESS
;
4831 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4832 (uint64_t)MEMCACHED_HASH_HSIEH
);
4833 test_true(rc
== expected_rc
);
4835 return TEST_SUCCESS
;
4838 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4840 memcached_return_t expected_rc
= MEMCACHED_FAILURE
;
4841 #ifdef HAVE_MURMUR_HASH
4842 expected_rc
= MEMCACHED_SUCCESS
;
4844 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4845 (uint64_t)MEMCACHED_HASH_MURMUR
);
4846 test_true(rc
== expected_rc
);
4848 return TEST_SUCCESS
;
4851 static test_return_t
one_at_a_time_run (memcached_st
*memc
__attribute__((unused
)))
4856 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4860 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
);
4861 test_true(one_at_a_time_values
[x
] == hash_val
);
4864 return TEST_SUCCESS
;
4867 static test_return_t
md5_run (memcached_st
*memc
__attribute__((unused
)))
4872 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4876 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4877 test_true(md5_values
[x
] == hash_val
);
4880 return TEST_SUCCESS
;
4883 static test_return_t
crc_run (memcached_st
*memc
__attribute__((unused
)))
4888 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4892 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4893 test_true(crc_values
[x
] == hash_val
);
4896 return TEST_SUCCESS
;
4899 static test_return_t
fnv1_64_run (memcached_st
*memc
__attribute__((unused
)))
4904 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4908 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4909 test_true(fnv1_64_values
[x
] == hash_val
);
4912 return TEST_SUCCESS
;
4915 static test_return_t
fnv1a_64_run (memcached_st
*memc
__attribute__((unused
)))
4920 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4924 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4925 test_true(fnv1a_64_values
[x
] == hash_val
);
4928 return TEST_SUCCESS
;
4931 static test_return_t
fnv1_32_run (memcached_st
*memc
__attribute__((unused
)))
4937 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4941 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4942 test_true(fnv1_32_values
[x
] == hash_val
);
4945 return TEST_SUCCESS
;
4948 static test_return_t
fnv1a_32_run (memcached_st
*memc
__attribute__((unused
)))
4953 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4957 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4958 test_true(fnv1a_32_values
[x
] == hash_val
);
4961 return TEST_SUCCESS
;
4964 static test_return_t
hsieh_run (memcached_st
*memc
__attribute__((unused
)))
4969 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4973 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4974 test_true(hsieh_values
[x
] == hash_val
);
4977 return TEST_SUCCESS
;
4980 static test_return_t
murmur_run (memcached_st
*memc
__attribute__((unused
)))
4982 #ifdef WORDS_BIGENDIAN
4983 (void)murmur_values
;
4984 return TEST_SKIPPED
;
4989 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4993 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
4994 test_true(murmur_values
[x
] == hash_val
);
4997 return TEST_SUCCESS
;
5001 static test_return_t
jenkins_run (memcached_st
*memc
__attribute__((unused
)))
5007 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5011 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
5012 test_true(jenkins_values
[x
] == hash_val
);
5015 return TEST_SUCCESS
;
5018 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *context
)
5021 return libhashkit_md5(string
, string_length
);
5024 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *context
)
5027 return libhashkit_crc32(string
, string_length
);
5030 static test_return_t
memcached_get_hashkit_test (memcached_st
*memc
)
5034 const hashkit_st
*kit
;
5036 hashkit_return_t hash_rc
;
5038 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};
5039 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};
5041 kit
= memcached_get_hashkit(memc
);
5043 hashkit_clone(&new_kit
, kit
);
5044 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
);
5045 test_true(hash_rc
== HASHKIT_SUCCESS
);
5047 memcached_set_hashkit(memc
, &new_kit
);
5050 Verify Setting the hash.
5052 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5056 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
5057 test_true(md5_values
[x
] == hash_val
);
5062 Now check memcached_st.
5064 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5068 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
5069 test_true(md5_hosts
[x
] == hash_val
);
5072 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
);
5073 test_true(hash_rc
== HASHKIT_SUCCESS
);
5075 memcached_set_hashkit(memc
, &new_kit
);
5078 Verify Setting the hash.
5080 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5084 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
5085 test_true(crc_values
[x
] == hash_val
);
5088 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5092 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
5093 test_true(crc_hosts
[x
] == hash_val
);
5096 return TEST_SUCCESS
;
5100 Test case adapted from John Gorman <johngorman2@gmail.com>
5102 We are testing the error condition when we connect to a server via memcached_get()
5103 but find that the server is not available.
5105 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*memc
)
5108 memcached_st
*tl_memc_h
;
5109 memcached_server_st
*servers
;
5111 const char *key
= "MemcachedLives";
5114 memcached_return rc
;
5118 tl_memc_h
= memcached_create(NULL
);
5119 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
5120 memcached_server_push(tl_memc_h
, servers
);
5121 memcached_server_list_free(servers
);
5123 // See if memcached is reachable.
5124 value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
5127 test_true(len
== 0);
5128 test_false(rc
== MEMCACHED_SUCCESS
);
5130 memcached_free(tl_memc_h
);
5132 return TEST_SUCCESS
;
5136 We connect to a server which exists, but search for a key that does not exist.
5138 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
5140 const char *key
= "MemcachedKeyNotEXIST";
5143 memcached_return rc
;
5146 // See if memcached is reachable.
5147 value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
5150 test_true(len
== 0);
5151 test_true(rc
== MEMCACHED_NOTFOUND
);
5153 return TEST_SUCCESS
;
5157 Test case adapted from John Gorman <johngorman2@gmail.com>
5159 We are testing the error condition when we connect to a server via memcached_get_by_key()
5160 but find that the server is not available.
5162 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
5165 memcached_st
*tl_memc_h
;
5166 memcached_server_st
*servers
;
5168 const char *key
= "MemcachedLives";
5171 memcached_return rc
;
5175 tl_memc_h
= memcached_create(NULL
);
5176 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
5177 memcached_server_push(tl_memc_h
, servers
);
5178 memcached_server_list_free(servers
);
5180 // See if memcached is reachable.
5181 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
5184 test_true(len
== 0);
5185 test_false(rc
== MEMCACHED_SUCCESS
);
5187 memcached_free(tl_memc_h
);
5189 return TEST_SUCCESS
;
5193 We connect to a server which exists, but search for a key that does not exist.
5195 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
5197 const char *key
= "MemcachedKeyNotEXIST";
5200 memcached_return rc
;
5203 // See if memcached is reachable.
5204 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
5207 test_true(len
== 0);
5208 test_true(rc
== MEMCACHED_NOTFOUND
);
5210 return TEST_SUCCESS
;
5214 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*trash
)
5216 memcached_return_t rc
;
5219 memcached_server_st
*server_pool
;
5224 memc
= memcached_create(NULL
);
5227 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5228 test_true(rc
== MEMCACHED_SUCCESS
);
5230 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5231 test_true(value
== 1);
5233 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
) == MEMCACHED_SUCCESS
);
5234 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
);
5237 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");
5238 memcached_server_push(memc
, server_pool
);
5240 /* verify that the server list was parsed okay. */
5241 test_true(memcached_server_count(memc
) == 8);
5242 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5243 test_true(server_pool
[0].port
== 11211);
5244 test_true(server_pool
[0].weight
== 600);
5245 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5246 test_true(server_pool
[2].port
== 11211);
5247 test_true(server_pool
[2].weight
== 200);
5248 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5249 test_true(server_pool
[7].port
== 11211);
5250 test_true(server_pool
[7].weight
== 100);
5252 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5253 * us test the boundary wraparound.
5255 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5257 /* verify the standard ketama set. */
5258 for (x
= 0; x
< 99; x
++)
5260 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
5261 memcached_server_instance_st instance
=
5262 memcached_server_instance_by_position(memc
, server_idx
);
5263 const char *hostname
= memcached_server_name(instance
);
5265 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
5268 memcached_server_list_free(server_pool
);
5269 memcached_free(memc
);
5271 return TEST_SUCCESS
;
5274 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*trash
)
5276 memcached_return_t rc
;
5279 memcached_server_st
*server_pool
;
5284 memc
= memcached_create(NULL
);
5287 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5288 test_true(rc
== MEMCACHED_SUCCESS
);
5290 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5291 test_true(value
== 1);
5293 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
5294 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
);
5296 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");
5297 memcached_server_push(memc
, server_pool
);
5299 /* verify that the server list was parsed okay. */
5300 test_true(memcached_server_count(memc
) == 8);
5301 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5302 test_true(server_pool
[0].port
== 11211);
5303 test_true(server_pool
[0].weight
== 600);
5304 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5305 test_true(server_pool
[2].port
== 11211);
5306 test_true(server_pool
[2].weight
== 200);
5307 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5308 test_true(server_pool
[7].port
== 11211);
5309 test_true(server_pool
[7].weight
== 100);
5311 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5312 * us test the boundary wraparound.
5314 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5316 /* verify the standard ketama set. */
5317 for (x
= 0; x
< 99; x
++)
5319 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
5321 memcached_server_instance_st instance
=
5322 memcached_server_instance_by_position(memc
, server_idx
);
5324 const char *hostname
= memcached_server_name(instance
);
5326 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
5329 memcached_server_list_free(server_pool
);
5330 memcached_free(memc
);
5332 return TEST_SUCCESS
;
5335 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5337 test_return_t test_rc
;
5338 test_rc
= pre_binary(memc
);
5340 if (test_rc
!= TEST_SUCCESS
)
5343 memcached_return_t ret
;
5344 const char *key
= "regression_bug_434484";
5345 size_t keylen
= strlen(key
);
5347 ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5348 test_true(ret
== MEMCACHED_NOTSTORED
);
5350 size_t size
= 2048 * 1024;
5351 void *data
= calloc(1, size
);
5352 test_true(data
!= NULL
);
5353 ret
= memcached_set(memc
, key
, keylen
, data
, size
, 0, 0);
5354 test_true(ret
== MEMCACHED_E2BIG
);
5357 return TEST_SUCCESS
;
5360 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5362 test_return_t test_rc
;
5363 test_rc
= pre_binary(memc
);
5365 if (test_rc
!= TEST_SUCCESS
)
5368 memcached_return_t rc
;
5370 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5373 * I only want to hit only _one_ server so I know the number of requests I'm
5374 * sending in the pipleine to the server. Let's try to do a multiget of
5375 * 1024 (that should satisfy most users don't you think?). Future versions
5376 * will include a mget_execute function call if you need a higher number.
5378 uint32_t number_of_hosts
= memcached_server_count(memc
);
5379 memc
->number_of_hosts
= 1;
5380 const size_t max_keys
= 1024;
5381 char **keys
= calloc(max_keys
, sizeof(char*));
5382 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5384 for (size_t x
= 0; x
< max_keys
; ++x
)
5388 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5390 test_true(keys
[x
] != NULL
);
5394 * Run two times.. the first time we should have 100% cache miss,
5395 * and the second time we should have 100% cache hits
5397 for (size_t y
= 0; y
< 2; y
++)
5399 rc
= memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
);
5400 test_true(rc
== MEMCACHED_SUCCESS
);
5401 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5405 /* The first iteration should give me a 100% cache miss. verify that*/
5406 char blob
[1024]= { 0 };
5408 test_true(counter
== 0);
5410 for (size_t x
= 0; x
< max_keys
; ++x
)
5412 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5413 blob
, sizeof(blob
), 0, 0);
5414 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5419 /* Verify that we received all of the key/value pairs */
5420 test_true(counter
== max_keys
);
5424 /* Release allocated resources */
5425 for (size_t x
= 0; x
< max_keys
; ++x
)
5432 memc
->number_of_hosts
= number_of_hosts
;
5434 return TEST_SUCCESS
;
5437 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5439 memcached_return_t rc
;
5440 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5441 test_true(rc
== MEMCACHED_SUCCESS
);
5443 return regression_bug_434843(memc
);
5446 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5448 memcached_return_t rc
;
5449 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5450 test_true(rc
== MEMCACHED_SUCCESS
);
5452 char *bytes
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5453 test_true(rc
== MEMCACHED_SUCCESS
);
5454 test_true(bytes
!= NULL
);
5455 char *bytes_read
= memcached_stat_get_value(memc
, memc_stat
,
5457 test_true(rc
== MEMCACHED_SUCCESS
);
5458 test_true(bytes_read
!= NULL
);
5460 char *bytes_written
= memcached_stat_get_value(memc
, memc_stat
,
5461 "bytes_written", &rc
);
5462 test_true(rc
== MEMCACHED_SUCCESS
);
5463 test_true(bytes_written
!= NULL
);
5465 test_true(strcmp(bytes
, bytes_read
) != 0);
5466 test_true(strcmp(bytes
, bytes_written
) != 0);
5468 /* Release allocated resources */
5471 free(bytes_written
);
5472 memcached_stat_free(NULL
, memc_stat
);
5474 return TEST_SUCCESS
;
5478 * The test case isn't obvious so I should probably document why
5479 * it works the way it does. Bug 442914 was caused by a bug
5480 * in the logic in memcached_purge (it did not handle the case
5481 * where the number of bytes sent was equal to the watermark).
5482 * In this test case, create messages so that we hit that case
5483 * and then disable noreply mode and issue a new command to
5484 * verify that it isn't stuck. If we change the format for the
5485 * delete command or the watermarks, we need to update this
5488 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5490 memcached_return_t rc
;
5491 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
5492 test_true(rc
== MEMCACHED_SUCCESS
);
5493 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5495 uint32_t number_of_hosts
= memcached_server_count(memc
);
5496 memc
->number_of_hosts
= 1;
5501 for (uint32_t x
= 0; x
< 250; ++x
)
5503 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5504 rc
= memcached_delete(memc
, k
, len
, 0);
5505 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5508 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5511 rc
= memcached_delete(memc
, k
, len
, 0);
5512 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5514 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0);
5515 test_true(rc
== MEMCACHED_SUCCESS
);
5516 rc
= memcached_delete(memc
, k
, len
, 0);
5517 test_true(rc
== MEMCACHED_NOTFOUND
);
5519 memc
->number_of_hosts
= number_of_hosts
;
5521 return TEST_SUCCESS
;
5524 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5526 memcached_server_instance_st instance_one
;
5527 memcached_server_instance_st instance_two
;
5529 if (memcached_server_count(memc
) < 3 || pre_replication(memc
) != TEST_SUCCESS
)
5530 return TEST_SKIPPED
;
5532 memcached_return_t rc
;
5534 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2);
5535 test_true(rc
== MEMCACHED_SUCCESS
);
5537 const size_t max_keys
= 100;
5538 char **keys
= calloc(max_keys
, sizeof(char*));
5539 size_t *key_length
= calloc(max_keys
, sizeof(size_t));
5541 for (size_t x
= 0; x
< max_keys
; ++x
)
5545 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5547 test_true(keys
[x
] != NULL
);
5548 rc
= memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0);
5549 test_true(rc
== MEMCACHED_SUCCESS
);
5553 ** We are using the quiet commands to store the replicas, so we need
5554 ** to ensure that all of them are processed before we can continue.
5555 ** In the test we go directly from storing the object to trying to
5556 ** receive the object from all of the different servers, so we
5557 ** could end up in a race condition (the memcached server hasn't yet
5558 ** processed the quiet command from the replication set when it process
5559 ** the request from the other client (created by the clone)). As a
5560 ** workaround for that we call memcached_quit to send the quit command
5561 ** to the server and wait for the response ;-) If you use the test code
5562 ** as an example for your own code, please note that you shouldn't need
5565 memcached_quit(memc
);
5567 /* Verify that all messages are stored, and we didn't stuff too much
5570 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5571 test_true(rc
== MEMCACHED_SUCCESS
);
5574 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5575 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5576 /* Verify that we received all of the key/value pairs */
5577 test_true(counter
== max_keys
);
5579 memcached_quit(memc
);
5581 * Don't do the following in your code. I am abusing the internal details
5582 * within the library, and this is not a supported interface.
5583 * This is to verify correct behavior in the library. Fake that two servers
5586 instance_one
= memcached_server_instance_by_position(memc
, 0);
5587 instance_two
= memcached_server_instance_by_position(memc
, 2);
5588 in_port_t port0
= instance_one
->port
;
5589 in_port_t port2
= instance_two
->port
;
5591 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5592 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5594 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5595 test_true(rc
== MEMCACHED_SUCCESS
);
5598 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5599 test_true(counter
== (unsigned int)max_keys
);
5601 /* restore the memc handle */
5602 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5603 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5605 memcached_quit(memc
);
5607 /* Remove half of the objects */
5608 for (size_t x
= 0; x
< max_keys
; ++x
)
5612 rc
= memcached_delete(memc
, keys
[x
], key_length
[x
], 0);
5613 test_true(rc
== MEMCACHED_SUCCESS
);
5617 memcached_quit(memc
);
5618 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5619 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5621 /* now retry the command, this time we should have cache misses */
5622 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5623 test_true(rc
== MEMCACHED_SUCCESS
);
5626 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5627 test_true(counter
== (unsigned int)(max_keys
>> 1));
5629 /* Release allocated resources */
5630 for (size_t x
= 0; x
< max_keys
; ++x
)
5637 /* restore the memc handle */
5638 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5639 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5641 return TEST_SUCCESS
;
5644 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5646 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5647 test_true(memc_clone
!= NULL
);
5648 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5650 memcached_server_instance_st instance
=
5651 memcached_server_instance_by_position(memc_clone
, 0);
5653 if (instance
->major_version
> 1 ||
5654 (instance
->major_version
== 1 &&
5655 instance
->minor_version
> 2))
5657 /* Binary protocol doesn't support deferred delete */
5658 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5659 test_true(bin_clone
!= NULL
);
5660 test_true(memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1) == MEMCACHED_SUCCESS
);
5661 test_true(memcached_delete(bin_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5662 memcached_free(bin_clone
);
5664 memcached_quit(memc_clone
);
5666 /* If we know the server version, deferred delete should fail
5667 * with invalid arguments */
5668 test_true(memcached_delete(memc_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5670 /* If we don't know the server version, we should get a protocol error */
5671 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5673 /* but there is a bug in some of the memcached servers (1.4) that treats
5674 * the counter as noreply so it doesn't send the proper error message
5676 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5678 /* And buffered mode should be disabled and we should get protocol error */
5679 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5680 rc
= memcached_delete(memc
, "foo", 3, 1);
5681 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5683 /* Same goes for noreply... */
5684 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1) == MEMCACHED_SUCCESS
);
5685 rc
= memcached_delete(memc
, "foo", 3, 1);
5686 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5688 /* but a normal request should go through (and be buffered) */
5689 test_true((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_BUFFERED
);
5690 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
5692 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0) == MEMCACHED_SUCCESS
);
5693 /* unbuffered noreply should be success */
5694 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_SUCCESS
);
5695 /* unbuffered with reply should be not found... */
5696 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0) == MEMCACHED_SUCCESS
);
5697 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_NOTFOUND
);
5700 memcached_free(memc_clone
);
5701 return TEST_SUCCESS
;
5705 /* Test memcached_server_get_last_disconnect
5706 * For a working server set, shall be NULL
5707 * For a set of non existing server, shall not be NULL
5709 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5711 memcached_return_t rc
;
5712 memcached_server_instance_st disconnected_server
;
5714 /* With the working set of server */
5715 const char *key
= "marmotte";
5716 const char *value
= "milka";
5718 memcached_reset_last_disconnected_server(memc
);
5719 rc
= memcached_set(memc
, key
, strlen(key
),
5720 value
, strlen(value
),
5721 (time_t)0, (uint32_t)0);
5722 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5724 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5725 test_true(disconnected_server
== NULL
);
5727 /* With a non existing server */
5729 memcached_server_st
*servers
;
5731 const char *server_list
= "localhost:9";
5733 servers
= memcached_servers_parse(server_list
);
5735 mine
= memcached_create(NULL
);
5736 rc
= memcached_server_push(mine
, servers
);
5737 test_true(rc
== MEMCACHED_SUCCESS
);
5738 memcached_server_list_free(servers
);
5741 rc
= memcached_set(mine
, key
, strlen(key
),
5742 value
, strlen(value
),
5743 (time_t)0, (uint32_t)0);
5744 test_true(rc
!= MEMCACHED_SUCCESS
);
5746 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5747 if (disconnected_server
== NULL
)
5749 fprintf(stderr
, "RC %s\n", memcached_strerror(mine
, rc
));
5752 test_true(disconnected_server
!= NULL
);
5753 test_true(memcached_server_port(disconnected_server
)== 9);
5754 test_true(strncmp(memcached_server_name(disconnected_server
),"localhost",9) == 0);
5756 memcached_quit(mine
);
5757 memcached_free(mine
);
5759 return TEST_SUCCESS
;
5762 static test_return_t
test_verbosity(memcached_st
*memc
)
5764 memcached_verbosity(memc
, 3);
5766 return TEST_SUCCESS
;
5769 static test_return_t
test_server_failure(memcached_st
*memc
)
5771 memcached_st
*local_memc
;
5772 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
5774 local_memc
= memcached_create(NULL
);
5776 memcached_server_add(local_memc
, memcached_server_name(instance
), memcached_server_port(instance
));
5777 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 2);
5779 uint32_t server_count
= memcached_server_count(local_memc
);
5781 test_true(server_count
== 1);
5783 // Disable the server
5784 instance
= memcached_server_instance_by_position(local_memc
, 0);
5785 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 2;
5787 memcached_return_t rc
;
5788 rc
= memcached_set(local_memc
, "foo", strlen("foo"),
5790 (time_t)0, (uint32_t)0);
5791 test_true(rc
== MEMCACHED_SERVER_MARKED_DEAD
);
5793 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5794 rc
= memcached_set(local_memc
, "foo", strlen("foo"),
5796 (time_t)0, (uint32_t)0);
5797 test_true(rc
== MEMCACHED_SUCCESS
);
5800 memcached_free(local_memc
);
5802 return TEST_SUCCESS
;
5805 static test_return_t
test_cull_servers(memcached_st
*memc
)
5807 uint32_t count
= memcached_server_count(memc
);
5809 // Do not do this in your code, it is not supported.
5810 memc
->servers
[1].state
.is_dead
= true;
5811 memc
->state
.is_time_for_rebuild
= true;
5813 uint32_t new_count
= memcached_server_count(memc
);
5814 test_true(count
== new_count
);
5817 test_true(count
== new_count
+ 1 );
5820 return TEST_SUCCESS
;
5824 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5825 const char *key
, size_t key_length
,
5826 const char *value
, size_t value_length
,
5836 return MEMCACHED_SUCCESS
;
5839 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5841 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5842 test_true(rc
== MEMCACHED_SUCCESS
);
5844 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5845 test_true(rc
== MEMCACHED_SUCCESS
);
5847 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5848 test_true(rc
== MEMCACHED_SUCCESS
);
5850 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5851 test_true(rc
== MEMCACHED_SUCCESS
);
5853 return TEST_SUCCESS
;
5857 * This test ensures that the failure counter isn't incremented during
5858 * normal termination of the memcached instance.
5860 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5862 memcached_return_t rc
;
5863 memcached_server_instance_st instance
;
5865 /* Set value to force connection to the server */
5866 const char *key
= "marmotte";
5867 const char *value
= "milka";
5870 * Please note that I'm abusing the internal structures in libmemcached
5871 * in a non-portable way and you shouldn't be doing this. I'm only
5872 * doing this in order to verify that the library works the way it should
5874 uint32_t number_of_hosts
= memcached_server_count(memc
);
5875 memc
->number_of_hosts
= 1;
5877 /* Ensure that we are connected to the server by setting a value */
5878 rc
= memcached_set(memc
, key
, strlen(key
),
5879 value
, strlen(value
),
5880 (time_t)0, (uint32_t)0);
5881 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5884 instance
= memcached_server_instance_by_position(memc
, 0);
5885 /* The test is to see that the memcached_quit doesn't increase the
5886 * the server failure conter, so let's ensure that it is zero
5887 * before sending quit
5889 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5891 memcached_quit(memc
);
5893 /* Verify that it memcached_quit didn't increment the failure counter
5894 * Please note that this isn't bullet proof, because an error could
5897 test_true(instance
->server_failure_counter
== 0);
5899 /* restore the instance */
5900 memc
->number_of_hosts
= number_of_hosts
;
5902 return TEST_SUCCESS
;
5909 * Test that ensures mget_execute does not end into recursive calls that finally fails
5911 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5913 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5914 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5915 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5916 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5917 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5920 return TEST_SKIPPED
; // My MAC can't handle this test
5924 * I only want to hit _one_ server so I know the number of requests I'm
5925 * sending in the pipeline.
5927 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5928 memc
->number_of_hosts
= 1;
5929 size_t max_keys
= 20480;
5932 char **keys
= calloc(max_keys
, sizeof(char*));
5933 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5935 /* First add all of the items.. */
5937 char blob
[1024]= { 0 };
5938 memcached_return rc
;
5939 for (size_t x
= 0; x
< max_keys
; ++x
)
5942 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5944 assert(keys
[x
] != NULL
);
5945 rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5947 if (rc
== MEMCACHED_SERVER_MARKED_DEAD
)
5949 break; // We are out of business
5952 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
); // MEMCACHED_TIMEOUT <-- only observed on OSX
5954 if (rc
== MEMCACHED_TIMEOUT
&& slept
== false)
5957 sleep(1);// We will try to sleep
5960 else if (rc
== MEMCACHED_TIMEOUT
&& slept
== true)
5962 // We failed to send everything.
5967 if (rc
!= MEMCACHED_SERVER_MARKED_DEAD
)
5970 /* Try to get all of them with a large multiget */
5972 memcached_execute_function callbacks
[1]= { [0]= &callback_counter
};
5973 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5974 (size_t)max_keys
, callbacks
, &counter
, 1);
5976 assert(rc
== MEMCACHED_SUCCESS
);
5977 char* the_value
= NULL
;
5978 char the_key
[MEMCACHED_MAX_KEY
];
5979 size_t the_key_length
;
5980 size_t the_value_length
;
5984 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5986 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5992 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5995 assert(rc
== MEMCACHED_END
);
5997 /* Verify that we got all of the items */
5998 assert(counter
== max_keys
);
6001 /* Release all allocated resources */
6002 for (size_t x
= 0; x
< max_keys
; ++x
)
6009 memc
->number_of_hosts
= number_of_hosts
;
6011 return TEST_SUCCESS
;
6014 static test_return_t
regression_bug_583031(memcached_st
*unused
)
6018 memcached_st
*memc
= memcached_create(NULL
);
6020 memcached_server_add(memc
, "10.2.3.4", 11211);
6022 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
6023 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
6024 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
6025 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
6026 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
6027 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
6029 memcached_return_t rc
;
6033 (void)memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
6035 test_true_got(rc
== MEMCACHED_TIMEOUT
, memcached_strerror(NULL
, rc
));
6037 memcached_free(memc
);
6039 return TEST_SUCCESS
;
6042 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
6044 fprintf(stderr
, "Iteration #%u: ", it
);
6046 if(error
== MEMCACHED_ERRNO
)
6048 fprintf(stderr
, "system error %d from %s: %s\n",
6049 errno
, what
, strerror(errno
));
6053 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
6054 memcached_strerror(mc
, error
));
6058 #define TEST_CONSTANT_CREATION 200
6060 static test_return_t
regression_bug_(memcached_st
*memc
)
6062 const char *remote_server
;
6065 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
6067 return TEST_SKIPPED
;
6070 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
6072 memcached_st
* mc
= memcached_create(NULL
);
6073 memcached_return rc
;
6075 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
6076 if (rc
!= MEMCACHED_SUCCESS
)
6078 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6081 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
6082 if (rc
!= MEMCACHED_SUCCESS
)
6084 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6087 rc
= memcached_server_add(mc
, remote_server
, 0);
6088 if (rc
!= MEMCACHED_SUCCESS
)
6090 memcached_die(mc
, rc
, "memcached_server_add", x
);
6093 const char *set_key
= "akey";
6094 const size_t set_key_len
= strlen(set_key
);
6095 const char *set_value
= "a value";
6096 const size_t set_value_len
= strlen(set_value
);
6098 if (rc
== MEMCACHED_SUCCESS
)
6102 size_t get_value_len
;
6104 uint32_t get_value_flags
;
6106 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
6107 &get_value_flags
, &rc
);
6108 if (rc
!= MEMCACHED_SUCCESS
)
6110 memcached_die(mc
, rc
, "memcached_get", x
);
6116 (get_value_len
!= set_value_len
6117 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
6119 fprintf(stderr
, "Values don't match?\n");
6120 rc
= MEMCACHED_FAILURE
;
6126 rc
= memcached_set(mc
,
6127 set_key
, set_key_len
,
6128 set_value
, set_value_len
,
6132 if (rc
!= MEMCACHED_SUCCESS
)
6134 memcached_die(mc
, rc
, "memcached_set", x
);
6141 if (rc
!= MEMCACHED_SUCCESS
)
6147 return TEST_SUCCESS
;
6151 * Test that the sasl authentication works. We cannot use the default
6152 * pool of servers, because that would require that all servers we want
6153 * to test supports SASL authentication, and that they use the default
6156 static test_return_t
sasl_auth_test(memcached_st
*memc
)
6158 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
6159 memcached_return_t rc
;
6161 rc
= memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
6162 test_true(rc
== MEMCACHED_SUCCESS
);
6163 test_true((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_SUCCESS
);
6164 test_true((rc
= memcached_destroy_sasl_auth_data(memc
)) == MEMCACHED_SUCCESS
);
6165 test_true((rc
= memcached_destroy_sasl_auth_data(memc
)) == MEMCACHED_FAILURE
);
6166 test_true((rc
= memcached_destroy_sasl_auth_data(NULL
)) == MEMCACHED_FAILURE
);
6167 memcached_quit(memc
);
6169 rc
= memcached_set_sasl_auth_data(memc
,
6170 getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
6171 getenv("LIBMEMCACHED_TEST_SASL_SERVER"));
6172 test_true(rc
== MEMCACHED_SUCCESS
);
6174 rc
= memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
6175 test_true(rc
== MEMCACHED_AUTH_FAILURE
);
6176 test_true(memcached_destroy_sasl_auth_data(memc
) == MEMCACHED_SUCCESS
);
6178 memcached_quit(memc
);
6179 return TEST_SUCCESS
;
6182 return TEST_FAILURE
;
6186 /* Clean the server before beginning testing */
6188 {"util_version", 1, (test_callback_fn
)util_version_test
},
6189 {"flush", 0, (test_callback_fn
)flush_test
},
6190 {"init", 0, (test_callback_fn
)init_test
},
6191 {"allocation", 0, (test_callback_fn
)allocation_test
},
6192 {"server_list_null_test", 0, (test_callback_fn
)server_list_null_test
},
6193 {"server_unsort", 0, (test_callback_fn
)server_unsort_test
},
6194 {"server_sort", 0, (test_callback_fn
)server_sort_test
},
6195 {"server_sort2", 0, (test_callback_fn
)server_sort2_test
},
6196 {"memcached_server_remove", 0, (test_callback_fn
)memcached_server_remove_test
},
6197 {"clone_test", 0, (test_callback_fn
)clone_test
},
6198 {"connection_test", 0, (test_callback_fn
)connection_test
},
6199 {"callback_test", 0, (test_callback_fn
)callback_test
},
6200 {"userdata_test", 0, (test_callback_fn
)userdata_test
},
6201 {"error", 0, (test_callback_fn
)error_test
},
6202 {"set", 0, (test_callback_fn
)set_test
},
6203 {"set2", 0, (test_callback_fn
)set_test2
},
6204 {"set3", 0, (test_callback_fn
)set_test3
},
6205 {"dump", 1, (test_callback_fn
)dump_test
},
6206 {"add", 1, (test_callback_fn
)add_test
},
6207 {"replace", 1, (test_callback_fn
)replace_test
},
6208 {"delete", 1, (test_callback_fn
)delete_test
},
6209 {"get", 1, (test_callback_fn
)get_test
},
6210 {"get2", 0, (test_callback_fn
)get_test2
},
6211 {"get3", 0, (test_callback_fn
)get_test3
},
6212 {"get4", 0, (test_callback_fn
)get_test4
},
6213 {"partial mget", 0, (test_callback_fn
)get_test5
},
6214 {"stats_servername", 0, (test_callback_fn
)stats_servername_test
},
6215 {"increment", 0, (test_callback_fn
)increment_test
},
6216 {"increment_with_initial", 1, (test_callback_fn
)increment_with_initial_test
},
6217 {"decrement", 0, (test_callback_fn
)decrement_test
},
6218 {"decrement_with_initial", 1, (test_callback_fn
)decrement_with_initial_test
},
6219 {"increment_by_key", 0, (test_callback_fn
)increment_by_key_test
},
6220 {"increment_with_initial_by_key", 1, (test_callback_fn
)increment_with_initial_by_key_test
},
6221 {"decrement_by_key", 0, (test_callback_fn
)decrement_by_key_test
},
6222 {"decrement_with_initial_by_key", 1, (test_callback_fn
)decrement_with_initial_by_key_test
},
6223 {"quit", 0, (test_callback_fn
)quit_test
},
6224 {"mget", 1, (test_callback_fn
)mget_test
},
6225 {"mget_result", 1, (test_callback_fn
)mget_result_test
},
6226 {"mget_result_alloc", 1, (test_callback_fn
)mget_result_alloc_test
},
6227 {"mget_result_function", 1, (test_callback_fn
)mget_result_function
},
6228 {"mget_execute", 1, (test_callback_fn
)mget_execute
},
6229 {"mget_end", 0, (test_callback_fn
)mget_end
},
6230 {"get_stats", 0, (test_callback_fn
)get_stats
},
6231 {"add_host_test", 0, (test_callback_fn
)add_host_test
},
6232 {"add_host_test_1", 0, (test_callback_fn
)add_host_test1
},
6233 {"get_stats_keys", 0, (test_callback_fn
)get_stats_keys
},
6234 {"version_string_test", 0, (test_callback_fn
)version_string_test
},
6235 {"bad_key", 1, (test_callback_fn
)bad_key_test
},
6236 {"memcached_server_cursor", 1, (test_callback_fn
)memcached_server_cursor_test
},
6237 {"read_through", 1, (test_callback_fn
)read_through
},
6238 {"delete_through", 1, (test_callback_fn
)delete_through
},
6239 {"noreply", 1, (test_callback_fn
)noreply_test
},
6240 {"analyzer", 1, (test_callback_fn
)analyzer_test
},
6241 #ifdef HAVE_LIBMEMCACHEDUTIL
6242 {"connectionpool", 1, (test_callback_fn
)connection_pool_test
},
6243 {"ping", 1, (test_callback_fn
)ping_test
},
6245 {"test_get_last_disconnect", 1, (test_callback_fn
)test_get_last_disconnect
},
6246 {"verbosity", 1, (test_callback_fn
)test_verbosity
},
6247 {"test_server_failure", 1, (test_callback_fn
)test_server_failure
},
6248 {"cull_servers", 1, (test_callback_fn
)test_cull_servers
},
6249 {"memcached_stat_execute", 1, (test_callback_fn
)memcached_stat_execute_test
},
6253 test_st behavior_tests
[] ={
6254 {"behavior_test", 0, (test_callback_fn
)behavior_test
},
6255 {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_CORK_test
},
6256 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
6257 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
6261 test_st regression_binary_vs_block
[] ={
6262 {"block add", 1, (test_callback_fn
)block_add_regression
},
6263 {"binary add", 1, (test_callback_fn
)binary_add_regression
},
6267 test_st async_tests
[] ={
6268 {"add", 1, (test_callback_fn
)add_wrapper
},
6272 test_st string_tests
[] ={
6273 {"string static with null", 0, (test_callback_fn
)string_static_null
},
6274 {"string alloc with null", 0, (test_callback_fn
)string_alloc_null
},
6275 {"string alloc with 1K", 0, (test_callback_fn
)string_alloc_with_size
},
6276 {"string alloc with malloc failure", 0, (test_callback_fn
)string_alloc_with_size_toobig
},
6277 {"string append", 0, (test_callback_fn
)string_alloc_append
},
6278 {"string append failure (too big)", 0, (test_callback_fn
)string_alloc_append_toobig
},
6279 {0, 0, (test_callback_fn
)0}
6282 test_st result_tests
[] ={
6283 {"result static", 0, (test_callback_fn
)result_static
},
6284 {"result alloc", 0, (test_callback_fn
)result_alloc
},
6285 {0, 0, (test_callback_fn
)0}
6288 test_st version_1_2_3
[] ={
6289 {"append", 0, (test_callback_fn
)append_test
},
6290 {"prepend", 0, (test_callback_fn
)prepend_test
},
6291 {"cas", 0, (test_callback_fn
)cas_test
},
6292 {"cas2", 0, (test_callback_fn
)cas2_test
},
6293 {"append_binary", 0, (test_callback_fn
)append_binary_test
},
6294 {0, 0, (test_callback_fn
)0}
6297 test_st user_tests
[] ={
6298 {"user_supplied_bug1", 0, (test_callback_fn
)user_supplied_bug1
},
6299 {"user_supplied_bug2", 0, (test_callback_fn
)user_supplied_bug2
},
6300 {"user_supplied_bug3", 0, (test_callback_fn
)user_supplied_bug3
},
6301 {"user_supplied_bug4", 0, (test_callback_fn
)user_supplied_bug4
},
6302 {"user_supplied_bug5", 1, (test_callback_fn
)user_supplied_bug5
},
6303 {"user_supplied_bug6", 1, (test_callback_fn
)user_supplied_bug6
},
6304 {"user_supplied_bug7", 1, (test_callback_fn
)user_supplied_bug7
},
6305 {"user_supplied_bug8", 1, (test_callback_fn
)user_supplied_bug8
},
6306 {"user_supplied_bug9", 1, (test_callback_fn
)user_supplied_bug9
},
6307 {"user_supplied_bug10", 1, (test_callback_fn
)user_supplied_bug10
},
6308 {"user_supplied_bug11", 1, (test_callback_fn
)user_supplied_bug11
},
6309 {"user_supplied_bug12", 1, (test_callback_fn
)user_supplied_bug12
},
6310 {"user_supplied_bug13", 1, (test_callback_fn
)user_supplied_bug13
},
6311 {"user_supplied_bug14", 1, (test_callback_fn
)user_supplied_bug14
},
6312 {"user_supplied_bug15", 1, (test_callback_fn
)user_supplied_bug15
},
6313 {"user_supplied_bug16", 1, (test_callback_fn
)user_supplied_bug16
},
6314 #if !defined(__sun) && !defined(__OpenBSD__)
6316 ** It seems to be something weird with the character sets..
6317 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6318 ** guess I need to find out how this is supposed to work.. Perhaps I need
6319 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6320 ** so just disable the code for now...).
6322 {"user_supplied_bug17", 1, (test_callback_fn
)user_supplied_bug17
},
6324 {"user_supplied_bug18", 1, (test_callback_fn
)user_supplied_bug18
},
6325 {"user_supplied_bug19", 1, (test_callback_fn
)user_supplied_bug19
},
6326 {"user_supplied_bug20", 1, (test_callback_fn
)user_supplied_bug20
},
6327 {"user_supplied_bug21", 1, (test_callback_fn
)user_supplied_bug21
},
6328 {"wrong_failure_counter_test", 1, (test_callback_fn
)wrong_failure_counter_test
},
6329 {0, 0, (test_callback_fn
)0}
6332 test_st replication_tests
[]= {
6333 {"set", 1, (test_callback_fn
)replication_set_test
},
6334 {"get", 0, (test_callback_fn
)replication_get_test
},
6335 {"mget", 0, (test_callback_fn
)replication_mget_test
},
6336 {"delete", 0, (test_callback_fn
)replication_delete_test
},
6337 {"rand_mget", 0, (test_callback_fn
)replication_randomize_mget_test
},
6338 {0, 0, (test_callback_fn
)0}
6342 * The following test suite is used to verify that we don't introduce
6343 * regression bugs. If you want more information about the bug / test,
6344 * you should look in the bug report at
6345 * http://bugs.launchpad.net/libmemcached
6347 test_st regression_tests
[]= {
6348 {"lp:434484", 1, (test_callback_fn
)regression_bug_434484
},
6349 {"lp:434843", 1, (test_callback_fn
)regression_bug_434843
},
6350 {"lp:434843-buffered", 1, (test_callback_fn
)regression_bug_434843_buffered
},
6351 {"lp:421108", 1, (test_callback_fn
)regression_bug_421108
},
6352 {"lp:442914", 1, (test_callback_fn
)regression_bug_442914
},
6353 {"lp:447342", 1, (test_callback_fn
)regression_bug_447342
},
6354 {"lp:463297", 1, (test_callback_fn
)regression_bug_463297
},
6355 {"lp:490486", 1, (test_callback_fn
)regression_bug_490486
},
6356 {"lp:583031", 1, (test_callback_fn
)regression_bug_583031
},
6357 {"lp:?", 1, (test_callback_fn
)regression_bug_
},
6358 {0, 0, (test_callback_fn
)0}
6361 test_st sasl_auth_tests
[]= {
6362 {"sasl_auth", 1, (test_callback_fn
)sasl_auth_test
},
6363 {0, 0, (test_callback_fn
)0}
6366 test_st ketama_compatibility
[]= {
6367 {"libmemcached", 1, (test_callback_fn
)ketama_compatibility_libmemcached
},
6368 {"spymemcached", 1, (test_callback_fn
)ketama_compatibility_spymemcached
},
6369 {0, 0, (test_callback_fn
)0}
6372 test_st generate_tests
[] ={
6373 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6374 {"generate_data", 1, (test_callback_fn
)generate_data
},
6375 {"get_read", 0, (test_callback_fn
)get_read
},
6376 {"delete_generate", 0, (test_callback_fn
)delete_generate
},
6377 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
6378 {"delete_buffer", 0, (test_callback_fn
)delete_buffer_generate
},
6379 {"generate_data", 1, (test_callback_fn
)generate_data
},
6380 {"mget_read", 0, (test_callback_fn
)mget_read
},
6381 {"mget_read_result", 0, (test_callback_fn
)mget_read_result
},
6382 {"mget_read_function", 0, (test_callback_fn
)mget_read_function
},
6383 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6384 {"generate_large_pairs", 1, (test_callback_fn
)generate_large_pairs
},
6385 {"generate_data", 1, (test_callback_fn
)generate_data
},
6386 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
6387 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6388 {0, 0, (test_callback_fn
)0}
6391 test_st consistent_tests
[] ={
6392 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6393 {"generate_data", 1, (test_callback_fn
)generate_data
},
6394 {"get_read", 0, (test_callback_fn
)get_read_count
},
6395 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6396 {0, 0, (test_callback_fn
)0}
6399 test_st consistent_weighted_tests
[] ={
6400 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6401 {"generate_data", 1, (test_callback_fn
)generate_data_with_stats
},
6402 {"get_read", 0, (test_callback_fn
)get_read_count
},
6403 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6404 {0, 0, (test_callback_fn
)0}
6407 test_st hsieh_availability
[] ={
6408 {"hsieh_avaibility_test", 0, (test_callback_fn
)hsieh_avaibility_test
},
6409 {0, 0, (test_callback_fn
)0}
6412 test_st murmur_availability
[] ={
6413 {"murmur_avaibility_test", 0, (test_callback_fn
)murmur_avaibility_test
},
6414 {0, 0, (test_callback_fn
)0}
6418 test_st hash_sanity
[] ={
6419 {"hash sanity", 0, (test_callback_fn
)hash_sanity_test
},
6420 {0, 0, (test_callback_fn
)0}
6424 test_st ketama_auto_eject_hosts
[] ={
6425 {"auto_eject_hosts", 1, (test_callback_fn
)auto_eject_hosts
},
6426 {"output_ketama_weighted_keys", 1, (test_callback_fn
)output_ketama_weighted_keys
},
6427 {0, 0, (test_callback_fn
)0}
6430 test_st hash_tests
[] ={
6431 {"one_at_a_time_run", 0, (test_callback_fn
)one_at_a_time_run
},
6432 {"md5", 0, (test_callback_fn
)md5_run
},
6433 {"crc", 0, (test_callback_fn
)crc_run
},
6434 {"fnv1_64", 0, (test_callback_fn
)fnv1_64_run
},
6435 {"fnv1a_64", 0, (test_callback_fn
)fnv1a_64_run
},
6436 {"fnv1_32", 0, (test_callback_fn
)fnv1_32_run
},
6437 {"fnv1a_32", 0, (test_callback_fn
)fnv1a_32_run
},
6438 {"hsieh", 0, (test_callback_fn
)hsieh_run
},
6439 {"murmur", 0, (test_callback_fn
)murmur_run
},
6440 {"jenkis", 0, (test_callback_fn
)jenkins_run
},
6441 {"memcached_get_hashkit", 0, (test_callback_fn
)memcached_get_hashkit_test
},
6442 {0, 0, (test_callback_fn
)0}
6445 test_st error_conditions
[] ={
6446 {"memcached_get_MEMCACHED_ERRNO", 0, (test_callback_fn
)memcached_get_MEMCACHED_ERRNO
},
6447 {"memcached_get_MEMCACHED_NOTFOUND", 0, (test_callback_fn
)memcached_get_MEMCACHED_NOTFOUND
},
6448 {"memcached_get_by_key_MEMCACHED_ERRNO", 0, (test_callback_fn
)memcached_get_by_key_MEMCACHED_ERRNO
},
6449 {"memcached_get_by_key_MEMCACHED_NOTFOUND", 0, (test_callback_fn
)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6450 {0, 0, (test_callback_fn
)0}
6453 collection_st collection
[] ={
6455 {"hash_sanity", 0, 0, hash_sanity
},
6457 {"hsieh_availability", 0, 0, hsieh_availability
},
6458 {"murmur_availability", 0, 0, murmur_availability
},
6459 {"block", 0, 0, tests
},
6460 {"binary", (test_callback_fn
)pre_binary
, 0, tests
},
6461 {"nonblock", (test_callback_fn
)pre_nonblock
, 0, tests
},
6462 {"nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6463 {"settimer", (test_callback_fn
)pre_settimer
, 0, tests
},
6464 {"md5", (test_callback_fn
)pre_md5
, 0, tests
},
6465 {"crc", (test_callback_fn
)pre_crc
, 0, tests
},
6466 {"hsieh", (test_callback_fn
)pre_hsieh
, 0, tests
},
6467 {"jenkins", (test_callback_fn
)pre_jenkins
, 0, tests
},
6468 {"fnv1_64", (test_callback_fn
)pre_hash_fnv1_64
, 0, tests
},
6469 {"fnv1a_64", (test_callback_fn
)pre_hash_fnv1a_64
, 0, tests
},
6470 {"fnv1_32", (test_callback_fn
)pre_hash_fnv1_32
, 0, tests
},
6471 {"fnv1a_32", (test_callback_fn
)pre_hash_fnv1a_32
, 0, tests
},
6472 {"ketama", (test_callback_fn
)pre_behavior_ketama
, 0, tests
},
6473 {"ketama_auto_eject_hosts", (test_callback_fn
)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6474 {"unix_socket", (test_callback_fn
)pre_unix_socket
, 0, tests
},
6475 {"unix_socket_nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6476 {"poll_timeout", (test_callback_fn
)poll_timeout
, 0, tests
},
6477 {"gets", (test_callback_fn
)enable_cas
, 0, tests
},
6478 {"consistent_crc", (test_callback_fn
)enable_consistent_crc
, 0, tests
},
6479 {"consistent_hsieh", (test_callback_fn
)enable_consistent_hsieh
, 0, tests
},
6480 #ifdef MEMCACHED_ENABLE_DEPRECATED
6481 {"deprecated_memory_allocators", (test_callback_fn
)deprecated_set_memory_alloc
, 0, tests
},
6483 {"memory_allocators", (test_callback_fn
)set_memory_alloc
, 0, tests
},
6484 {"prefix", (test_callback_fn
)set_prefix
, 0, tests
},
6485 {"sasl_auth", (test_callback_fn
)pre_sasl
, 0, sasl_auth_tests
},
6486 {"sasl", (test_callback_fn
)pre_sasl
, 0, tests
},
6487 {"version_1_2_3", (test_callback_fn
)check_for_1_2_3
, 0, version_1_2_3
},
6488 {"string", 0, 0, string_tests
},
6489 {"result", 0, 0, result_tests
},
6490 {"async", (test_callback_fn
)pre_nonblock
, 0, async_tests
},
6491 {"async_binary", (test_callback_fn
)pre_nonblock_binary
, 0, async_tests
},
6492 {"user", 0, 0, user_tests
},
6493 {"generate", 0, 0, generate_tests
},
6494 {"generate_hsieh", (test_callback_fn
)pre_hsieh
, 0, generate_tests
},
6495 {"generate_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, generate_tests
},
6496 {"generate_hsieh_consistent", (test_callback_fn
)enable_consistent_hsieh
, 0, generate_tests
},
6497 {"generate_md5", (test_callback_fn
)pre_md5
, 0, generate_tests
},
6498 {"generate_murmur", (test_callback_fn
)pre_murmur
, 0, generate_tests
},
6499 {"generate_jenkins", (test_callback_fn
)pre_jenkins
, 0, generate_tests
},
6500 {"generate_nonblock", (test_callback_fn
)pre_nonblock
, 0, generate_tests
},
6502 {"generate_corked", (test_callback_fn
)pre_cork
, 0, generate_tests
},
6503 {"generate_corked_and_nonblock", (test_callback_fn
)pre_cork_and_nonblock
, 0, generate_tests
},
6504 {"consistent_not", 0, 0, consistent_tests
},
6505 {"consistent_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, consistent_tests
},
6506 {"consistent_ketama_weighted", (test_callback_fn
)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6507 {"ketama_compat", 0, 0, ketama_compatibility
},
6508 {"test_hashes", 0, 0, hash_tests
},
6509 {"replication", (test_callback_fn
)pre_replication
, 0, replication_tests
},
6510 {"replication_noblock", (test_callback_fn
)pre_replication_noblock
, 0, replication_tests
},
6511 {"regression", 0, 0, regression_tests
},
6512 {"behaviors", 0, 0, behavior_tests
},
6513 {"regression_binary_vs_block", (test_callback_fn
)key_setup
, (test_callback_fn
)key_teardown
, regression_binary_vs_block
},
6514 {"error_conditions", 0, 0, error_conditions
},
6518 #define SERVERS_TO_CREATE 5
6520 #include "libmemcached_world.h"
6522 void get_world(world_st
*world
)
6524 world
->collections
= collection
;
6526 world
->create
= (test_callback_create_fn
)world_create
;
6527 world
->destroy
= (test_callback_fn
)world_destroy
;
6529 world
->test
.startup
= (test_callback_fn
)world_test_startup
;
6530 world
->test
.flush
= (test_callback_fn
)world_flush
;
6531 world
->test
.pre_run
= (test_callback_fn
)world_pre_run
;
6532 world
->test
.post_run
= (test_callback_fn
)world_post_run
;
6533 world
->test
.on_error
= (test_callback_error_fn
)world_on_error
;
6535 world
->collection
.startup
= (test_callback_fn
)world_container_startup
;
6536 world
->collection
.shutdown
= (test_callback_fn
)world_container_shutdown
;
6538 world
->runner
= &defualt_libmemcached_runner
;