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
)
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
;
2066 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2067 &return_value_length
, &flags
, &rc
)))
2069 test_true(return_value
);
2070 test_true(rc
== MEMCACHED_SUCCESS
);
2074 test_true_got(rc
== MEMCACHED_END
|| rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
2076 return TEST_SUCCESS
;
2079 /* Test case provided by Cal Haldenbrand */
2080 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2082 unsigned int setter
= 1;
2084 unsigned long long total
= 0;
2087 char randomstuff
[6 * 1024];
2088 memcached_return_t rc
;
2090 memset(randomstuff
, 0, 6 * 1024);
2092 /* We just keep looking at the same values over and over */
2095 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2096 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2100 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2104 size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2105 memset(randomstuff
, 0, 6 * 1024);
2106 test_true(size
< 6 * 1024); /* Being safe here */
2108 for (j
= 0 ; j
< size
;j
++)
2109 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2112 snprintf(key
, sizeof(key
), "%u", x
);
2113 rc
= memcached_set(memc
, key
, strlen(key
),
2114 randomstuff
, strlen(randomstuff
), 10, 0);
2115 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2116 /* If we fail, lets try again */
2117 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
2118 rc
= memcached_set(memc
, key
, strlen(key
),
2119 randomstuff
, strlen(randomstuff
), 10, 0);
2120 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2123 return TEST_SUCCESS
;
2126 /* Test case provided by Cal Haldenbrand */
2127 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2129 unsigned int setter
;
2133 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2134 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2136 setter
= 20 * 1024576;
2137 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2138 setter
= 20 * 1024576;
2139 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2140 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2141 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2143 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2146 for (uint32_t x
= 0, errors
= 0; total
< 24576 ; x
++)
2148 memcached_return_t rc
= MEMCACHED_SUCCESS
;
2149 char buffer
[SMALL_STRING_LEN
];
2154 memset(buffer
, 0, SMALL_STRING_LEN
);
2156 snprintf(buffer
, sizeof(buffer
), "%u", x
);
2157 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
2158 &val_len
, &flags
, &rc
);
2159 if (rc
!= MEMCACHED_SUCCESS
)
2161 if (rc
== MEMCACHED_NOTFOUND
)
2175 return TEST_SUCCESS
;
2178 /* Do a large mget() over all the keys we think exist */
2179 #define KEY_COUNT 3000 // * 1024576
2180 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2182 memcached_return_t rc
;
2183 unsigned int setter
;
2186 size_t key_lengths
[KEY_COUNT
];
2189 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2190 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2192 setter
= 20 * 1024576;
2193 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2194 setter
= 20 * 1024576;
2195 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2196 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2197 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2200 keys
= calloc(KEY_COUNT
, sizeof(char *));
2202 for (x
= 0; x
< KEY_COUNT
; x
++)
2206 snprintf(buffer
, 30, "%u", x
);
2207 keys
[x
]= strdup(buffer
);
2208 key_lengths
[x
]= strlen(keys
[x
]);
2211 rc
= memcached_mget(memc
, (const char **)keys
, key_lengths
, KEY_COUNT
);
2212 test_true(rc
== MEMCACHED_SUCCESS
);
2214 test_true(fetch_all_results(memc
) == TEST_SUCCESS
);
2216 for (x
= 0; x
< KEY_COUNT
; x
++)
2220 return TEST_SUCCESS
;
2223 /* Make sure we behave properly if server list has no values */
2224 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2226 memcached_return_t rc
;
2227 const char *keys
[]= {"fudge", "son", "food"};
2228 size_t key_length
[]= {5, 3, 4};
2231 char return_key
[MEMCACHED_MAX_KEY
];
2232 size_t return_key_length
;
2234 size_t return_value_length
;
2236 /* Here we free everything before running a bunch of mget tests */
2237 memcached_servers_reset(memc
);
2240 /* We need to empty the server before continueing test */
2241 rc
= memcached_flush(memc
, 0);
2242 test_true(rc
== MEMCACHED_NO_SERVERS
);
2244 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2245 test_true(rc
== MEMCACHED_NO_SERVERS
);
2247 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2248 &return_value_length
, &flags
, &rc
)) != NULL
)
2250 test_true(return_value
);
2252 test_true(!return_value
);
2253 test_true(return_value_length
== 0);
2254 test_true(rc
== MEMCACHED_NO_SERVERS
);
2256 for (x
= 0; x
< 3; x
++)
2258 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2259 keys
[x
], key_length
[x
],
2260 (time_t)50, (uint32_t)9);
2261 test_true(rc
== MEMCACHED_NO_SERVERS
);
2264 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2265 test_true(rc
== MEMCACHED_NO_SERVERS
);
2268 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2269 &return_value_length
, &flags
, &rc
)))
2271 test_true(return_value
);
2272 test_true(rc
== MEMCACHED_SUCCESS
);
2273 test_true(return_key_length
== return_value_length
);
2274 test_true(!memcmp(return_value
, return_key
, return_value_length
));
2279 return TEST_SUCCESS
;
2282 #define VALUE_SIZE_BUG5 1048064
2283 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2285 memcached_return_t rc
;
2286 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2287 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2288 char return_key
[MEMCACHED_MAX_KEY
];
2289 size_t return_key_length
;
2291 size_t value_length
;
2295 char insert_data
[VALUE_SIZE_BUG5
];
2297 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2298 insert_data
[x
]= (signed char)rand();
2300 memcached_flush(memc
, 0);
2301 value
= memcached_get(memc
, keys
[0], key_length
[0],
2302 &value_length
, &flags
, &rc
);
2303 test_true(value
== NULL
);
2304 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2307 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2308 &value_length
, &flags
, &rc
)))
2310 test_true(count
== 0);
2312 for (x
= 0; x
< 4; x
++)
2314 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2315 insert_data
, VALUE_SIZE_BUG5
,
2316 (time_t)0, (uint32_t)0);
2317 test_true(rc
== MEMCACHED_SUCCESS
);
2320 for (x
= 0; x
< 10; x
++)
2322 value
= memcached_get(memc
, keys
[0], key_length
[0],
2323 &value_length
, &flags
, &rc
);
2327 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2329 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2330 &value_length
, &flags
, &rc
)))
2335 test_true(count
== 4);
2338 return TEST_SUCCESS
;
2341 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2343 memcached_return_t rc
;
2344 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2345 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2346 char return_key
[MEMCACHED_MAX_KEY
];
2347 size_t return_key_length
;
2349 size_t value_length
;
2353 char insert_data
[VALUE_SIZE_BUG5
];
2355 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2356 insert_data
[x
]= (signed char)rand();
2358 memcached_flush(memc
, 0);
2359 value
= memcached_get(memc
, keys
[0], key_length
[0],
2360 &value_length
, &flags
, &rc
);
2361 test_true(value
== NULL
);
2362 test_true(rc
== MEMCACHED_NOTFOUND
);
2363 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2364 test_true(rc
== MEMCACHED_SUCCESS
);
2367 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2368 &value_length
, &flags
, &rc
)))
2370 test_true(count
== 0);
2371 test_true(rc
== MEMCACHED_END
);
2373 for (x
= 0; x
< 4; x
++)
2375 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2376 insert_data
, VALUE_SIZE_BUG5
,
2377 (time_t)0, (uint32_t)0);
2378 test_true(rc
== MEMCACHED_SUCCESS
);
2381 for (x
= 0; x
< 2; x
++)
2383 value
= memcached_get(memc
, keys
[0], key_length
[0],
2384 &value_length
, &flags
, &rc
);
2388 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2389 test_true(rc
== MEMCACHED_SUCCESS
);
2391 /* We test for purge of partial complete fetches */
2392 for (count
= 3; count
; count
--)
2394 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2395 &value_length
, &flags
, &rc
);
2396 test_true(rc
== MEMCACHED_SUCCESS
);
2397 test_true(!(memcmp(value
, insert_data
, value_length
)));
2398 test_true(value_length
);
2403 return TEST_SUCCESS
;
2406 static test_return_t
user_supplied_bug8(memcached_st
*memc
__attribute__((unused
)))
2408 memcached_return_t rc
;
2410 memcached_st
*memc_clone
;
2412 memcached_server_st
*servers
;
2413 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";
2415 servers
= memcached_servers_parse(server_list
);
2418 mine
= memcached_create(NULL
);
2419 rc
= memcached_server_push(mine
, servers
);
2420 test_true(rc
== MEMCACHED_SUCCESS
);
2421 memcached_server_list_free(servers
);
2424 memc_clone
= memcached_clone(NULL
, mine
);
2426 memcached_quit(mine
);
2427 memcached_quit(memc_clone
);
2430 memcached_free(mine
);
2431 memcached_free(memc_clone
);
2433 return TEST_SUCCESS
;
2436 /* Test flag store/retrieve */
2437 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2439 memcached_return_t rc
;
2440 const char *keys
= "036790384900";
2441 size_t key_length
= strlen(keys
);
2442 char return_key
[MEMCACHED_MAX_KEY
];
2443 size_t return_key_length
;
2445 size_t value_length
;
2448 char insert_data
[VALUE_SIZE_BUG5
];
2450 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2451 insert_data
[x
]= (signed char)rand();
2453 memcached_flush(memc
, 0);
2456 rc
= memcached_set(memc
, keys
, key_length
,
2457 insert_data
, VALUE_SIZE_BUG5
,
2459 test_true(rc
== MEMCACHED_SUCCESS
);
2462 value
= memcached_get(memc
, keys
, key_length
,
2463 &value_length
, &flags
, &rc
);
2464 test_true(flags
== 245);
2468 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2471 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2472 &value_length
, &flags
, &rc
);
2473 test_true(flags
== 245);
2478 return TEST_SUCCESS
;
2481 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2483 memcached_return_t rc
;
2484 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2485 size_t key_length
[3];
2490 char return_key
[MEMCACHED_MAX_KEY
];
2491 size_t return_key_length
;
2493 size_t return_value_length
;
2496 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2497 key_length
[1]= strlen("fudge&*@#");
2498 key_length
[2]= strlen("for^#@&$not");
2501 for (x
= 0; x
< 3; x
++)
2503 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2504 keys
[x
], key_length
[x
],
2505 (time_t)50, (uint32_t)9);
2506 test_true(rc
== MEMCACHED_SUCCESS
);
2509 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2510 test_true(rc
== MEMCACHED_SUCCESS
);
2512 /* We need to empty the server before continueing test */
2513 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2514 &return_value_length
, &flags
, &rc
)) != NULL
)
2516 test_true(return_value
);
2520 test_true(count
== 3);
2522 return TEST_SUCCESS
;
2525 /* We are testing with aggressive timeout to get failures */
2526 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2528 const char *key
= "foo";
2530 size_t value_length
= 512;
2533 memcached_return_t rc
;
2534 unsigned int set
= 1;
2535 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2538 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2539 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2541 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2544 value
= (char*)malloc(value_length
* sizeof(char));
2546 for (x
= 0; x
< value_length
; x
++)
2547 value
[x
]= (char) (x
% 127);
2549 for (x
= 1; x
<= 100000; ++x
)
2551 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2553 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2554 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2556 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2561 memcached_free(mclone
);
2563 return TEST_SUCCESS
;
2567 We are looking failures in the async protocol
2569 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2571 const char *key
= "foo";
2573 size_t value_length
= 512;
2576 memcached_return_t rc
;
2577 unsigned int set
= 1;
2579 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2581 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2582 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2584 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2587 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2589 test_true(timeout
== -1);
2591 value
= (char*)malloc(value_length
* sizeof(char));
2593 for (x
= 0; x
< value_length
; x
++)
2594 value
[x
]= (char) (x
% 127);
2596 for (x
= 1; x
<= 100000; ++x
)
2598 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2602 memcached_free(mclone
);
2604 return TEST_SUCCESS
;
2608 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2610 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2612 memcached_return_t rc
;
2614 size_t value_length
;
2616 uint64_t number_value
;
2618 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2619 &value_length
, &flags
, &rc
);
2620 test_true(value
== NULL
);
2621 test_true(rc
== MEMCACHED_NOTFOUND
);
2623 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2626 test_true(value
== NULL
);
2627 /* The binary protocol will set the key if it doesn't exist */
2628 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2630 test_true(rc
== MEMCACHED_SUCCESS
);
2634 test_true(rc
== MEMCACHED_NOTFOUND
);
2637 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2639 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2640 &value_length
, &flags
, &rc
);
2642 test_true(rc
== MEMCACHED_SUCCESS
);
2645 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2647 test_true(number_value
== 2);
2648 test_true(rc
== MEMCACHED_SUCCESS
);
2650 return TEST_SUCCESS
;
2654 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2655 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2657 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2659 char key
[] = "key34567890";
2661 memcached_return_t rc
;
2662 size_t overflowSize
;
2664 char commandFirst
[]= "set key34567890 0 0 ";
2665 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2666 size_t commandLength
;
2669 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2671 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2673 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2675 overflow
= malloc(testSize
);
2676 test_true(overflow
!= NULL
);
2678 memset(overflow
, 'x', testSize
);
2679 rc
= memcached_set(memc
, key
, strlen(key
),
2680 overflow
, testSize
, 0, 0);
2681 test_true(rc
== MEMCACHED_SUCCESS
);
2685 return TEST_SUCCESS
;
2690 Test values of many different sizes
2691 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2692 set key34567890 0 0 8169 \r\n
2693 is sent followed by buffer of size 8169, followed by 8169
2695 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2698 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2699 memcached_return_t rc
;
2700 const char *key
= "foo";
2702 size_t value_length
= 18000;
2704 size_t string_length
;
2707 size_t current_length
;
2709 value
= (char*)malloc(value_length
);
2712 for (x
= 0; x
< value_length
; x
++)
2713 value
[x
] = (char) (x
% 127);
2715 for (current_length
= 0; current_length
< value_length
; current_length
++)
2717 rc
= memcached_set(memc
, key
, strlen(key
),
2718 value
, current_length
,
2719 (time_t)0, (uint32_t)0);
2720 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2722 string
= memcached_get(memc
, key
, strlen(key
),
2723 &string_length
, &flags
, &rc
);
2725 test_true(rc
== MEMCACHED_SUCCESS
);
2726 test_true(string_length
== current_length
);
2727 test_true(!memcmp(string
, value
, string_length
));
2734 return TEST_SUCCESS
;
2738 Look for zero length value problems
2740 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2743 memcached_return_t rc
;
2744 const char *key
= "mykey";
2749 for (x
= 0; x
< 2; x
++)
2751 rc
= memcached_set(memc
, key
, strlen(key
),
2753 (time_t)0, (uint32_t)0);
2755 test_true(rc
== MEMCACHED_SUCCESS
);
2757 value
= memcached_get(memc
, key
, strlen(key
),
2758 &length
, &flags
, &rc
);
2760 test_true(rc
== MEMCACHED_SUCCESS
);
2761 test_true(value
== NULL
);
2762 test_true(length
== 0);
2763 test_true(flags
== 0);
2765 value
= memcached_get(memc
, key
, strlen(key
),
2766 &length
, &flags
, &rc
);
2768 test_true(rc
== MEMCACHED_SUCCESS
);
2769 test_true(value
== NULL
);
2770 test_true(length
== 0);
2771 test_true(flags
== 0);
2774 return TEST_SUCCESS
;
2777 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2778 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2780 memcached_return_t rc
;
2781 const char *key
= "mykey";
2786 rc
= memcached_set(memc
, key
, strlen(key
),
2788 (time_t)0, UINT32_MAX
);
2790 test_true(rc
== MEMCACHED_SUCCESS
);
2792 value
= memcached_get(memc
, key
, strlen(key
),
2793 &length
, &flags
, &rc
);
2795 test_true(rc
== MEMCACHED_SUCCESS
);
2796 test_true(value
== NULL
);
2797 test_true(length
== 0);
2798 test_true(flags
== UINT32_MAX
);
2800 return TEST_SUCCESS
;
2803 #if !defined(__sun) && !defined(__OpenBSD__)
2804 /* Check the validity of chinese key*/
2805 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2807 memcached_return_t rc
;
2808 const char *key
= "豆瓣";
2809 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2814 rc
= memcached_set(memc
, key
, strlen(key
),
2815 value
, strlen(value
),
2818 test_true(rc
== MEMCACHED_SUCCESS
);
2820 value2
= memcached_get(memc
, key
, strlen(key
),
2821 &length
, &flags
, &rc
);
2823 test_true(length
==strlen(value
));
2824 test_true(rc
== MEMCACHED_SUCCESS
);
2825 test_true(memcmp(value
, value2
, length
)==0);
2828 return TEST_SUCCESS
;
2836 static test_return_t
user_supplied_bug19(memcached_st
*not_used
)
2839 const memcached_server_st
*server
;
2840 memcached_return_t res
;
2844 memc
= memcached_create(NULL
);
2845 memcached_server_add_with_weight(memc
, "localhost", 11311, 100);
2846 memcached_server_add_with_weight(memc
, "localhost", 11312, 100);
2848 server
= memcached_server_by_key(memc
, "a", 1, &res
);
2850 memcached_free(memc
);
2852 return TEST_SUCCESS
;
2855 /* CAS test from Andei */
2856 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2858 memcached_return_t status
;
2859 memcached_result_st
*result
, result_obj
;
2860 const char *key
= "abc";
2861 size_t key_len
= strlen("abc");
2862 const char *value
= "foobar";
2863 size_t value_len
= strlen(value
);
2865 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2867 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2868 test_true(status
== MEMCACHED_SUCCESS
);
2870 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2871 test_true(status
== MEMCACHED_SUCCESS
);
2873 result
= memcached_result_create(memc
, &result_obj
);
2876 memcached_result_create(memc
, &result_obj
);
2877 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2880 test_true(status
== MEMCACHED_SUCCESS
);
2882 memcached_result_free(result
);
2884 return TEST_SUCCESS
;
2887 #include "ketama_test_cases.h"
2888 static test_return_t
user_supplied_bug18(memcached_st
*trash
)
2890 memcached_return_t rc
;
2893 memcached_server_st
*server_pool
;
2898 memc
= memcached_create(NULL
);
2901 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2902 test_true(rc
== MEMCACHED_SUCCESS
);
2904 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2905 test_true(value
== 1);
2907 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2908 test_true(rc
== MEMCACHED_SUCCESS
);
2910 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2911 test_true(value
== MEMCACHED_HASH_MD5
);
2913 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");
2914 memcached_server_push(memc
, server_pool
);
2916 /* verify that the server list was parsed okay. */
2917 test_true(memcached_server_count(memc
) == 8);
2918 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2919 test_true(server_pool
[0].port
== 11211);
2920 test_true(server_pool
[0].weight
== 600);
2921 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2922 test_true(server_pool
[2].port
== 11211);
2923 test_true(server_pool
[2].weight
== 200);
2924 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2925 test_true(server_pool
[7].port
== 11211);
2926 test_true(server_pool
[7].weight
== 100);
2928 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2929 * us test the boundary wraparound.
2931 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
2933 /* verify the standard ketama set. */
2934 for (x
= 0; x
< 99; x
++)
2936 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2938 memcached_server_instance_st instance
=
2939 memcached_server_instance_by_position(memc
, server_idx
);
2941 const char *hostname
= memcached_server_name(instance
);
2942 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
2945 memcached_server_list_free(server_pool
);
2946 memcached_free(memc
);
2948 return TEST_SUCCESS
;
2951 /* Large mget() of missing keys with binary proto
2953 * If many binary quiet commands (such as getq's in an mget) fill the output
2954 * buffer and the server chooses not to respond, memcached_flush hangs. See
2955 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2958 /* sighandler_t function that always asserts false */
2959 static void fail(int unused
__attribute__((unused
)))
2965 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2970 return TEST_SKIPPED
;
2972 memcached_return_t rc
;
2975 size_t* key_lengths
;
2976 void (*oldalarm
)(int);
2977 memcached_st
*memc_clone
;
2979 memc_clone
= memcached_clone(NULL
, memc
);
2980 test_true(memc_clone
);
2982 /* only binproto uses getq for mget */
2983 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2985 /* empty the cache to ensure misses (hence non-responses) */
2986 rc
= memcached_flush(memc_clone
, 0);
2987 test_true(rc
== MEMCACHED_SUCCESS
);
2989 key_lengths
= calloc(key_count
, sizeof(size_t));
2990 keys
= calloc(key_count
, sizeof(char *));
2992 for (x
= 0; x
< key_count
; x
++)
2996 snprintf(buffer
, 30, "%u", x
);
2997 keys
[x
]= strdup(buffer
);
2998 key_lengths
[x
]= strlen(keys
[x
]);
3001 oldalarm
= signal(SIGALRM
, fail
);
3004 rc
= memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
);
3005 test_true(rc
== MEMCACHED_SUCCESS
);
3008 signal(SIGALRM
, oldalarm
);
3010 test_true(fetch_all_results(memc
) == TEST_SUCCESS
);
3012 for (x
= 0; x
< key_count
; x
++)
3017 memcached_free(memc_clone
);
3019 return TEST_SUCCESS
;
3023 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3025 test_return_t test_rc
;
3026 test_rc
= pre_binary(memc
);
3028 if (test_rc
!= TEST_SUCCESS
)
3033 /* should work as of r580 */
3034 rc
= _user_supplied_bug21(memc
, 10);
3035 test_true(rc
== TEST_SUCCESS
);
3037 /* should fail as of r580 */
3038 rc
= _user_supplied_bug21(memc
, 1000);
3039 test_true(rc
== TEST_SUCCESS
);
3041 return TEST_SUCCESS
;
3044 static test_return_t
auto_eject_hosts(memcached_st
*trash
)
3047 memcached_server_instance_st instance
;
3049 memcached_return_t rc
;
3050 memcached_st
*memc
= memcached_create(NULL
);
3053 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3054 test_true(rc
== MEMCACHED_SUCCESS
);
3056 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3057 test_true(value
== 1);
3059 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3060 test_true(rc
== MEMCACHED_SUCCESS
);
3062 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3063 test_true(value
== MEMCACHED_HASH_MD5
);
3065 /* server should be removed when in delay */
3066 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
3067 test_true(rc
== MEMCACHED_SUCCESS
);
3069 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
3070 test_true(value
== 1);
3072 memcached_server_st
*server_pool
;
3073 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");
3074 memcached_server_push(memc
, server_pool
);
3076 /* verify that the server list was parsed okay. */
3077 test_true(memcached_server_count(memc
) == 8);
3078 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
3079 test_true(server_pool
[0].port
== 11211);
3080 test_true(server_pool
[0].weight
== 600);
3081 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
3082 test_true(server_pool
[2].port
== 11211);
3083 test_true(server_pool
[2].weight
== 200);
3084 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
3085 test_true(server_pool
[7].port
== 11211);
3086 test_true(server_pool
[7].weight
== 100);
3088 instance
= memcached_server_instance_by_position(memc
, 2);
3089 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) + 15;
3090 memc
->next_distribution_rebuild
= time(NULL
) - 1;
3093 This would not work if there were only two hosts.
3095 for (size_t x
= 0; x
< 99; x
++)
3097 memcached_autoeject(memc
);
3098 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3099 test_true(server_idx
!= 2);
3102 /* and re-added when it's back. */
3103 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) - 1;
3104 memc
->next_distribution_rebuild
= time(NULL
) - 1;
3105 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
,
3106 memc
->distribution
);
3107 for (size_t x
= 0; x
< 99; x
++)
3109 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3110 // We re-use instance from above.
3112 memcached_server_instance_by_position(memc
, server_idx
);
3113 const char *hostname
= memcached_server_name(instance
);
3114 test_true(strcmp(hostname
, ketama_test_cases
[x
].server
) == 0);
3117 memcached_server_list_free(server_pool
);
3118 memcached_free(memc
);
3120 return TEST_SUCCESS
;
3123 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
3127 memcached_return_t rc
;
3128 memcached_st
*memc
= memcached_create(NULL
);
3132 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3133 test_true(rc
== MEMCACHED_SUCCESS
);
3135 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3136 test_true(value
== 1);
3138 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3139 test_true(rc
== MEMCACHED_SUCCESS
);
3141 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3142 test_true(value
== MEMCACHED_HASH_MD5
);
3145 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3147 memcached_server_st
*server_pool
;
3148 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");
3149 memcached_server_push(memc
, server_pool
);
3151 // @todo this needs to be refactored to actually test something.
3154 if ((fp
= fopen("ketama_keys.txt", "w")))
3158 printf("cannot write to file ketama_keys.txt");
3159 return TEST_FAILURE
;
3162 for (int x
= 0; x
< 10000; x
++)
3165 snprintf(key
, sizeof(key
), "%d", x
);
3167 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3168 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3169 in_port_t port
= memc
->hosts
[server_idx
].port
;
3170 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3171 memcached_server_instance_st instance
=
3172 memcached_server_instance_by_position(memc
, host_index
);
3176 memcached_server_list_free(server_pool
);
3177 memcached_free(memc
);
3179 return TEST_SUCCESS
;
3183 static test_return_t
result_static(memcached_st
*memc
)
3185 memcached_result_st result
;
3186 memcached_result_st
*result_ptr
;
3188 result_ptr
= memcached_result_create(memc
, &result
);
3189 test_true(result
.options
.is_allocated
== false);
3190 test_true(memcached_is_initialized(&result
) == true);
3191 test_true(result_ptr
);
3192 test_true(result_ptr
== &result
);
3194 memcached_result_free(&result
);
3196 test_true(result
.options
.is_allocated
== false);
3197 test_true(memcached_is_initialized(&result
) == false);
3199 return TEST_SUCCESS
;
3202 static test_return_t
result_alloc(memcached_st
*memc
)
3204 memcached_result_st
*result_ptr
;
3206 result_ptr
= memcached_result_create(memc
, NULL
);
3207 test_true(result_ptr
);
3208 test_true(result_ptr
->options
.is_allocated
== true);
3209 test_true(memcached_is_initialized(result_ptr
) == true);
3210 memcached_result_free(result_ptr
);
3212 return TEST_SUCCESS
;
3215 static test_return_t
string_static_null(memcached_st
*memc
)
3217 memcached_string_st string
;
3218 memcached_string_st
*string_ptr
;
3220 string_ptr
= memcached_string_create(memc
, &string
, 0);
3221 test_true(string
.options
.is_initialized
== true);
3222 test_true(string_ptr
);
3224 /* The following two better be the same! */
3225 test_true(memcached_is_allocated(string_ptr
) == false);
3226 test_true(memcached_is_allocated(&string
) == false);
3227 test_true(&string
== string_ptr
);
3229 test_true(string
.options
.is_initialized
== true);
3230 test_true(memcached_is_initialized(&string
) == true);
3231 memcached_string_free(&string
);
3232 test_true(memcached_is_initialized(&string
) == false);
3234 return TEST_SUCCESS
;
3237 static test_return_t
string_alloc_null(memcached_st
*memc
)
3239 memcached_string_st
*string
;
3241 string
= memcached_string_create(memc
, NULL
, 0);
3243 test_true(memcached_is_allocated(string
) == true);
3244 test_true(memcached_is_initialized(string
) == true);
3245 memcached_string_free(string
);
3247 return TEST_SUCCESS
;
3250 static test_return_t
string_alloc_with_size(memcached_st
*memc
)
3252 memcached_string_st
*string
;
3254 string
= memcached_string_create(memc
, NULL
, 1024);
3256 test_true(memcached_is_allocated(string
) == true);
3257 test_true(memcached_is_initialized(string
) == true);
3258 memcached_string_free(string
);
3260 return TEST_SUCCESS
;
3263 static test_return_t
string_alloc_with_size_toobig(memcached_st
*memc
)
3265 memcached_string_st
*string
;
3267 string
= memcached_string_create(memc
, NULL
, SIZE_MAX
);
3268 test_true(string
== NULL
);
3270 return TEST_SUCCESS
;
3273 static test_return_t
string_alloc_append(memcached_st
*memc
)
3276 char buffer
[SMALL_STRING_LEN
];
3277 memcached_string_st
*string
;
3279 /* Ring the bell! */
3280 memset(buffer
, 6, SMALL_STRING_LEN
);
3282 string
= memcached_string_create(memc
, NULL
, 100);
3284 test_true(memcached_is_allocated(string
) == true);
3285 test_true(memcached_is_initialized(string
) == true);
3287 for (x
= 0; x
< 1024; x
++)
3289 memcached_return_t rc
;
3290 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
3291 test_true(rc
== MEMCACHED_SUCCESS
);
3293 test_true(memcached_is_allocated(string
) == true);
3294 memcached_string_free(string
);
3296 return TEST_SUCCESS
;
3299 static test_return_t
string_alloc_append_toobig(memcached_st
*memc
)
3301 memcached_return_t rc
;
3303 char buffer
[SMALL_STRING_LEN
];
3304 memcached_string_st
*string
;
3306 /* Ring the bell! */
3307 memset(buffer
, 6, SMALL_STRING_LEN
);
3309 string
= memcached_string_create(memc
, NULL
, 100);
3311 test_true(memcached_is_allocated(string
) == true);
3312 test_true(memcached_is_initialized(string
) == true);
3314 for (x
= 0; x
< 1024; x
++)
3316 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
3317 test_true(rc
== MEMCACHED_SUCCESS
);
3319 rc
= memcached_string_append(string
, buffer
, SIZE_MAX
);
3320 test_true(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
3321 test_true(memcached_is_allocated(string
) == true);
3322 memcached_string_free(string
);
3324 return TEST_SUCCESS
;
3327 static test_return_t
cleanup_pairs(memcached_st
*memc
__attribute__((unused
)))
3329 pairs_free(global_pairs
);
3331 return TEST_SUCCESS
;
3334 static test_return_t
generate_pairs(memcached_st
*memc
__attribute__((unused
)))
3336 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3337 global_count
= GLOBAL_COUNT
;
3339 for (size_t x
= 0; x
< global_count
; x
++)
3341 global_keys
[x
]= global_pairs
[x
].key
;
3342 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3345 return TEST_SUCCESS
;
3348 static test_return_t
generate_large_pairs(memcached_st
*memc
__attribute__((unused
)))
3350 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3351 global_count
= GLOBAL2_COUNT
;
3353 for (size_t x
= 0; x
< global_count
; x
++)
3355 global_keys
[x
]= global_pairs
[x
].key
;
3356 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3359 return TEST_SUCCESS
;
3362 static test_return_t
generate_data(memcached_st
*memc
)
3364 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3366 test_true(check_execute
== global_count
);
3368 return TEST_SUCCESS
;
3371 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3373 memcached_stat_st
*stat_p
;
3374 memcached_return_t rc
;
3375 uint32_t host_index
= 0;
3376 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3378 test_true(check_execute
== global_count
);
3380 //TODO: hosts used size stats
3381 stat_p
= memcached_stat(memc
, NULL
, &rc
);
3384 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3386 /* This test was changes so that "make test" would work properlly */
3388 memcached_server_instance_st instance
=
3389 memcached_server_instance_by_position(memc
, host_index
);
3391 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3393 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3396 memcached_stat_free(NULL
, stat_p
);
3398 return TEST_SUCCESS
;
3400 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3405 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3406 generate_data(memc
);
3408 return TEST_SUCCESS
;
3411 static test_return_t
get_read_count(memcached_st
*memc
)
3413 memcached_return_t rc
;
3414 memcached_st
*memc_clone
;
3416 memc_clone
= memcached_clone(NULL
, memc
);
3417 test_true(memc_clone
);
3419 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3423 size_t return_value_length
;
3427 for (size_t x
= count
= 0; x
< global_count
; x
++)
3429 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3430 &return_value_length
, &flags
, &rc
);
3431 if (rc
== MEMCACHED_SUCCESS
)
3440 memcached_free(memc_clone
);
3442 return TEST_SUCCESS
;
3445 static test_return_t
get_read(memcached_st
*memc
)
3447 memcached_return_t rc
;
3451 size_t return_value_length
;
3454 for (size_t x
= 0; x
< global_count
; x
++)
3456 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3457 &return_value_length
, &flags
, &rc
);
3459 test_true(return_value);
3460 test_true(rc == MEMCACHED_SUCCESS);
3462 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3467 return TEST_SUCCESS
;
3470 static test_return_t
mget_read(memcached_st
*memc
)
3472 memcached_return_t rc
;
3474 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3475 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
3476 test_true(fetch_all_results(memc
) == TEST_SUCCESS
);
3478 return TEST_SUCCESS
;
3481 static test_return_t
mget_read_result(memcached_st
*memc
)
3483 memcached_return_t rc
;
3485 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3486 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
3487 /* Turn this into a help function */
3489 memcached_result_st results_obj
;
3490 memcached_result_st
*results
;
3492 results
= memcached_result_create(memc
, &results_obj
);
3494 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3497 test_true(rc
== MEMCACHED_SUCCESS
);
3500 memcached_result_free(&results_obj
);
3503 return TEST_SUCCESS
;
3506 static test_return_t
mget_read_function(memcached_st
*memc
)
3508 memcached_return_t rc
;
3510 memcached_execute_fn callbacks
[1];
3512 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3513 test_true_got(rc
== MEMCACHED_SUCCESS
, memcached_strerror(NULL
, rc
));
3515 callbacks
[0]= &callback_counter
;
3517 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
3519 return TEST_SUCCESS
;
3522 static test_return_t
delete_generate(memcached_st
*memc
)
3524 for (size_t x
= 0; x
< global_count
; x
++)
3526 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3529 return TEST_SUCCESS
;
3532 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3537 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3539 for (size_t x
= 0; x
< global_count
; x
++)
3541 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3544 return TEST_SUCCESS
;
3547 static test_return_t
add_host_test1(memcached_st
*memc
)
3549 memcached_return_t rc
;
3550 char servername
[]= "0.example.com";
3551 memcached_server_st
*servers
;
3553 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3555 test_true(1 == memcached_server_list_count(servers
));
3557 for (size_t x
= 2; x
< 20; x
++)
3559 char buffer
[SMALL_STRING_LEN
];
3561 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3562 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3564 test_true(rc
== MEMCACHED_SUCCESS
);
3565 test_true(x
== memcached_server_list_count(servers
));
3568 rc
= memcached_server_push(memc
, servers
);
3569 test_true(rc
== MEMCACHED_SUCCESS
);
3570 rc
= memcached_server_push(memc
, servers
);
3571 test_true(rc
== MEMCACHED_SUCCESS
);
3573 memcached_server_list_free(servers
);
3575 return TEST_SUCCESS
;
3578 static test_return_t
pre_nonblock(memcached_st
*memc
)
3580 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3582 return TEST_SUCCESS
;
3585 static test_return_t
pre_cork(memcached_st
*memc
)
3587 memcached_return_t rc
;
3590 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
3593 return TEST_SKIPPED
;
3596 if (rc
== MEMCACHED_SUCCESS
)
3597 return TEST_SUCCESS
;
3599 return TEST_SKIPPED
;
3602 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3609 return TEST_SKIPPED
;
3612 if (rc
!= TEST_SUCCESS
)
3615 return pre_nonblock(memc
);
3618 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3620 memcached_return_t rc
= MEMCACHED_FAILURE
;
3621 memcached_st
*memc_clone
;
3623 memc_clone
= memcached_clone(NULL
, memc
);
3624 test_true(memc_clone
);
3625 // The memcached_version needs to be done on a clone, because the server
3626 // will not toggle protocol on an connection.
3627 memcached_version(memc_clone
);
3629 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3631 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3632 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3633 test_true(rc
== MEMCACHED_SUCCESS
);
3634 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3638 return TEST_SKIPPED
;
3641 memcached_free(memc_clone
);
3643 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3646 static test_return_t
pre_murmur(memcached_st
*memc
)
3648 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3650 return TEST_SUCCESS
;
3653 static test_return_t
pre_jenkins(memcached_st
*memc
)
3655 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3657 return TEST_SUCCESS
;
3661 static test_return_t
pre_md5(memcached_st
*memc
)
3663 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3665 return TEST_SUCCESS
;
3668 static test_return_t
pre_crc(memcached_st
*memc
)
3670 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3672 return TEST_SUCCESS
;
3675 static test_return_t
pre_hsieh(memcached_st
*memc
)
3677 #ifdef HAVE_HSIEH_HASH
3678 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3679 return TEST_SUCCESS
;
3682 return TEST_SKIPPED
;
3686 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3688 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3690 return TEST_SUCCESS
;
3693 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3695 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3697 return TEST_SUCCESS
;
3700 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3702 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3704 return TEST_SUCCESS
;
3707 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3709 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3711 return TEST_SUCCESS
;
3714 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3716 memcached_return_t rc
;
3719 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3720 test_true(rc
== MEMCACHED_SUCCESS
);
3722 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3723 test_true(value
== 1);
3725 return TEST_SUCCESS
;
3728 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3730 memcached_return_t rc
;
3733 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3734 test_true(rc
== MEMCACHED_SUCCESS
);
3736 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3737 test_true(value
== 1);
3739 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3740 test_true(rc
== MEMCACHED_SUCCESS
);
3742 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3743 test_true(value
== MEMCACHED_HASH_MD5
);
3745 return TEST_SUCCESS
;
3749 @note This should be testing to see if the server really supports the binary protocol.
3751 static test_return_t
pre_binary(memcached_st
*memc
)
3753 memcached_return_t rc
= MEMCACHED_FAILURE
;
3755 if (libmemcached_util_version_check(memc
, 1, 4, 4))
3757 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3758 test_true(rc
== MEMCACHED_SUCCESS
);
3759 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3762 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3765 static test_return_t
pre_sasl(memcached_st
*memc
)
3767 memcached_return_t rc
= MEMCACHED_FAILURE
;
3769 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
3770 const char *server
= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
3771 const char *user
= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
3772 const char *pass
= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
3774 if (server
!= NULL
&& user
!= NULL
&& pass
!= NULL
)
3776 memcached_server_st
*servers
= memcached_servers_parse(server
);
3777 test_true(servers
!= NULL
);
3778 memcached_servers_reset(memc
);
3779 test_true(memcached_server_push(memc
, servers
) == MEMCACHED_SUCCESS
);
3780 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3781 rc
= memcached_set_sasl_auth_data(memc
, user
, pass
);
3782 test_true(rc
== MEMCACHED_SUCCESS
);
3788 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3791 static test_return_t
pre_replication(memcached_st
*memc
)
3793 test_return_t test_rc
;
3794 test_rc
= pre_binary(memc
);
3796 if (test_rc
!= TEST_SUCCESS
)
3800 * Make sure that we store the item on all servers
3801 * (master + replicas == number of servers)
3803 memcached_return_t rc
;
3804 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3805 memcached_server_count(memc
) - 1);
3806 test_true(rc
== MEMCACHED_SUCCESS
);
3807 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memcached_server_count(memc
) - 1);
3809 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3813 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3817 rc
= pre_replication(memc
);
3818 if (rc
!= TEST_SUCCESS
)
3821 rc
= pre_nonblock(memc
);
3827 static void my_free(const memcached_st
*ptr
__attribute__((unused
)), void *mem
, void *context
)
3830 #ifdef HARD_MALLOC_TESTS
3831 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3839 static void *my_malloc(const memcached_st
*ptr
__attribute__((unused
)), const size_t size
, void *context
)
3842 #ifdef HARD_MALLOC_TESTS
3843 void *ret
= malloc(size
+ 8);
3846 ret
= (void*)((caddr_t
)ret
+ 8);
3849 void *ret
= malloc(size
);
3854 memset(ret
, 0xff, size
);
3861 static void *my_realloc(const memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
, void *context
)
3864 #ifdef HARD_MALLOC_TESTS
3865 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3866 void *nmem
= realloc(real_ptr
, size
+ 8);
3871 ret
= (void*)((caddr_t
)nmem
+ 8);
3876 return realloc(mem
, size
);
3881 static void *my_calloc(const memcached_st
*ptr
__attribute__((unused
)), size_t nelem
, const size_t size
, void *context
)
3884 #ifdef HARD_MALLOC_TESTS
3885 void *mem
= my_malloc(ptr
, nelem
* size
);
3888 memset(mem
, 0, nelem
* size
);
3893 return calloc(nelem
, size
);
3898 static test_return_t
set_prefix(memcached_st
*memc
)
3900 memcached_return_t rc
;
3901 const char *key
= "mine";
3904 /* Make sure be default none exists */
3905 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3906 test_true(rc
== MEMCACHED_FAILURE
);
3908 /* Test a clean set */
3909 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3910 test_true(rc
== MEMCACHED_SUCCESS
);
3912 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3913 test_true(memcmp(value
, key
, 4) == 0);
3914 test_true(rc
== MEMCACHED_SUCCESS
);
3916 /* Test that we can turn it off */
3917 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3918 test_true(rc
== MEMCACHED_SUCCESS
);
3920 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3921 test_true(rc
== MEMCACHED_FAILURE
);
3923 /* Now setup for main test */
3924 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3925 test_true(rc
== MEMCACHED_SUCCESS
);
3927 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3928 test_true(rc
== MEMCACHED_SUCCESS
);
3929 test_true(memcmp(value
, key
, 4) == 0);
3931 /* Set to Zero, and then Set to something too large */
3934 memset(long_key
, 0, 255);
3936 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3937 test_true(rc
== MEMCACHED_SUCCESS
);
3939 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3940 test_true(rc
== MEMCACHED_FAILURE
);
3941 test_true(value
== NULL
);
3943 /* Test a long key for failure */
3944 /* TODO, extend test to determine based on setting, what result should be */
3945 strcpy(long_key
, "Thisismorethentheallottednumberofcharacters");
3946 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3947 //test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3948 test_true(rc
== MEMCACHED_SUCCESS
);
3950 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3951 strcpy(long_key
, "This is more then the allotted number of characters");
3952 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3953 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3955 /* Test for a bad prefix, but with a short key */
3956 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3957 test_true(rc
== MEMCACHED_SUCCESS
);
3959 strcpy(long_key
, "dog cat");
3960 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3961 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3964 return TEST_SUCCESS
;
3968 #ifdef MEMCACHED_ENABLE_DEPRECATED
3969 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3971 void *test_ptr
= NULL
;
3974 memcached_malloc_fn malloc_cb
=
3975 (memcached_malloc_fn
)my_malloc
;
3976 cb_ptr
= *(void **)&malloc_cb
;
3977 memcached_return_t rc
;
3979 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
3980 test_true(rc
== MEMCACHED_SUCCESS
);
3981 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3982 test_true(rc
== MEMCACHED_SUCCESS
);
3983 test_true(test_ptr
== cb_ptr
);
3987 memcached_realloc_fn realloc_cb
=
3988 (memcached_realloc_fn
)my_realloc
;
3989 cb_ptr
= *(void **)&realloc_cb
;
3990 memcached_return_t rc
;
3992 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
3993 test_true(rc
== MEMCACHED_SUCCESS
);
3994 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3995 test_true(rc
== MEMCACHED_SUCCESS
);
3996 test_true(test_ptr
== cb_ptr
);
4000 memcached_free_fn free_cb
=
4001 (memcached_free_fn
)my_free
;
4002 cb_ptr
= *(void **)&free_cb
;
4003 memcached_return_t rc
;
4005 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
4006 test_true(rc
== MEMCACHED_SUCCESS
);
4007 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
4008 test_true(rc
== MEMCACHED_SUCCESS
);
4009 test_true(test_ptr
== cb_ptr
);
4012 return TEST_SUCCESS
;
4017 static test_return_t
set_memory_alloc(memcached_st
*memc
)
4019 memcached_return_t rc
;
4020 rc
= memcached_set_memory_allocators(memc
, NULL
, my_free
,
4021 my_realloc
, my_calloc
, NULL
);
4022 test_true(rc
== MEMCACHED_FAILURE
);
4024 rc
= memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
4025 my_realloc
, my_calloc
, NULL
);
4027 memcached_malloc_fn mem_malloc
;
4028 memcached_free_fn mem_free
;
4029 memcached_realloc_fn mem_realloc
;
4030 memcached_calloc_fn mem_calloc
;
4031 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
4032 &mem_realloc
, &mem_calloc
);
4034 test_true(mem_malloc
== my_malloc
);
4035 test_true(mem_realloc
== my_realloc
);
4036 test_true(mem_calloc
== my_calloc
);
4037 test_true(mem_free
== my_free
);
4039 return TEST_SUCCESS
;
4042 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
4045 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4046 memcached_hash_t hash
;
4047 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4048 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
4051 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4052 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4054 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4056 if (hash
!= MEMCACHED_HASH_CRC
)
4057 return TEST_SKIPPED
;
4059 return TEST_SUCCESS
;
4062 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
4065 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4066 memcached_hash_t hash
;
4067 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4068 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
4071 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4072 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4074 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4076 if (hash
!= MEMCACHED_HASH_HSIEH
)
4077 return TEST_SKIPPED
;
4080 return TEST_SUCCESS
;
4083 static test_return_t
enable_cas(memcached_st
*memc
)
4085 unsigned int set
= 1;
4087 if (libmemcached_util_version_check(memc
, 1, 2, 4))
4089 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
4091 return TEST_SUCCESS
;
4094 return TEST_SKIPPED
;
4097 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
4099 memcached_version(memc
);
4101 memcached_server_instance_st instance
=
4102 memcached_server_instance_by_position(memc
, 0);
4104 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
4105 || instance
->minor_version
> 2)
4107 return TEST_SUCCESS
;
4110 return TEST_SKIPPED
;
4113 static test_return_t
pre_unix_socket(memcached_st
*memc
)
4115 memcached_return_t rc
;
4118 memcached_servers_reset(memc
);
4120 if (stat("/tmp/memcached.socket", &buf
))
4121 return TEST_SKIPPED
;
4123 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
4125 return ( rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_FAILURE
);
4128 static test_return_t
pre_nodelay(memcached_st
*memc
)
4130 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
4131 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
4133 return TEST_SUCCESS
;
4136 static test_return_t
pre_settimer(memcached_st
*memc
)
4138 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4139 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4141 return TEST_SUCCESS
;
4144 static test_return_t
poll_timeout(memcached_st
*memc
)
4150 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4152 timeout
= (size_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
4154 test_true(timeout
== 100);
4156 return TEST_SUCCESS
;
4159 static test_return_t
noreply_test(memcached_st
*memc
)
4161 memcached_return_t ret
;
4162 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
4163 test_true(ret
== MEMCACHED_SUCCESS
);
4164 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4165 test_true(ret
== MEMCACHED_SUCCESS
);
4166 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
4167 test_true(ret
== MEMCACHED_SUCCESS
);
4168 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
4169 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
4170 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
4172 for (int count
=0; count
< 5; ++count
)
4174 for (size_t x
= 0; x
< 100; ++x
)
4177 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4178 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4180 size_t len
= (size_t)check_length
;
4185 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4188 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4191 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4194 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4197 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4203 test_true(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
4207 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4208 ** API and is _ONLY_ done this way to verify that the library works the
4209 ** way it is supposed to do!!!!
4212 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4214 memcached_server_instance_st instance
=
4215 memcached_server_instance_by_position(memc
, x
);
4216 no_msg
+=(int)(instance
->cursor_active
);
4219 test_true(no_msg
== 0);
4220 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4223 ** Now validate that all items was set properly!
4225 for (size_t x
= 0; x
< 100; ++x
)
4229 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4231 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4233 size_t len
= (size_t)check_length
;
4236 char* value
=memcached_get(memc
, key
, strlen(key
),
4237 &length
, &flags
, &ret
);
4238 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4241 case 0: /* FALLTHROUGH */
4242 case 1: /* FALLTHROUGH */
4244 test_true(strncmp(value
, key
, len
) == 0);
4245 test_true(len
== length
);
4248 test_true(length
== len
* 2);
4251 test_true(length
== len
* 3);
4261 /* Try setting an illegal cas value (should not return an error to
4262 * the caller (because we don't expect a return message from the server)
4264 const char* keys
[]= {"0"};
4265 size_t lengths
[]= {1};
4268 memcached_result_st results_obj
;
4269 memcached_result_st
*results
;
4270 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4271 test_true(ret
== MEMCACHED_SUCCESS
);
4273 results
= memcached_result_create(memc
, &results_obj
);
4275 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4277 test_true(ret
== MEMCACHED_SUCCESS
);
4278 uint64_t cas
= memcached_result_cas(results
);
4279 memcached_result_free(&results_obj
);
4281 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4282 test_true(ret
== MEMCACHED_SUCCESS
);
4285 * The item will have a new cas value, so try to set it again with the old
4286 * value. This should fail!
4288 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4289 test_true(ret
== MEMCACHED_SUCCESS
);
4290 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4291 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4292 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4295 return TEST_SUCCESS
;
4298 static test_return_t
analyzer_test(memcached_st
*memc
)
4300 memcached_return_t rc
;
4301 memcached_stat_st
*memc_stat
;
4302 memcached_analysis_st
*report
;
4304 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4305 test_true(rc
== MEMCACHED_SUCCESS
);
4306 test_true(memc_stat
);
4308 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4309 test_true(rc
== MEMCACHED_SUCCESS
);
4313 memcached_stat_free(NULL
, memc_stat
);
4315 return TEST_SUCCESS
;
4318 /* Count the objects */
4319 static memcached_return_t
callback_dump_counter(const memcached_st
*ptr
__attribute__((unused
)),
4320 const char *key
__attribute__((unused
)),
4321 size_t key_length
__attribute__((unused
)),
4324 size_t *counter
= (size_t *)context
;
4326 *counter
= *counter
+ 1;
4328 return MEMCACHED_SUCCESS
;
4331 static test_return_t
dump_test(memcached_st
*memc
)
4333 memcached_return_t rc
;
4335 memcached_dump_fn callbacks
[1];
4336 test_return_t main_rc
;
4338 callbacks
[0]= &callback_dump_counter
;
4340 /* No support for Binary protocol yet */
4341 if (memc
->flags
.binary_protocol
)
4342 return TEST_SUCCESS
;
4344 main_rc
= set_test3(memc
);
4346 test_true (main_rc
== TEST_SUCCESS
);
4348 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
4349 test_true(rc
== MEMCACHED_SUCCESS
);
4351 /* We may have more then 32 if our previous flush has not completed */
4352 test_true(counter
>= 32);
4354 return TEST_SUCCESS
;
4357 #ifdef HAVE_LIBMEMCACHEDUTIL
4358 static void* connection_release(void *arg
)
4361 memcached_pool_st
* pool
;
4366 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
4370 #define POOL_SIZE 10
4371 static test_return_t
connection_pool_test(memcached_st
*memc
)
4373 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4374 test_true(pool
!= NULL
);
4375 memcached_st
*mmc
[POOL_SIZE
];
4376 memcached_return_t rc
;
4378 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4380 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4381 test_true(mmc
[x
] != NULL
);
4382 test_true(rc
== MEMCACHED_SUCCESS
);
4385 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4386 test_true(rc
== MEMCACHED_SUCCESS
);
4390 memcached_pool_st
* pool
;
4392 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
4393 pthread_create(&tid
, NULL
, connection_release
, &item
);
4394 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4395 test_true(rc
== MEMCACHED_SUCCESS
);
4396 pthread_join(tid
, NULL
);
4397 test_true(mmc
[9] == item
.mmc
);
4398 const char *key
= "key";
4399 size_t keylen
= strlen(key
);
4401 // verify that I can do ops with all connections
4402 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
4403 test_true(rc
== MEMCACHED_SUCCESS
);
4405 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4407 uint64_t number_value
;
4408 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
4409 test_true(rc
== MEMCACHED_SUCCESS
);
4410 test_true(number_value
== (x
+1));
4414 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4416 test_true(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
4420 /* verify that I can set behaviors on the pool when I don't have all
4421 * of the connections in the pool. It should however be enabled
4422 * when I push the item into the pool
4424 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4425 test_true(mmc
[0] != NULL
);
4427 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4428 test_true(rc
== MEMCACHED_SUCCESS
);
4430 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4431 test_true(mmc
[1] != NULL
);
4433 test_true(memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4434 test_true(memcached_pool_push(pool
, mmc
[1]) == MEMCACHED_SUCCESS
);
4435 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4437 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4438 test_true(memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4439 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4441 test_true(memcached_pool_destroy(pool
) == memc
);
4443 return TEST_SUCCESS
;
4446 static test_return_t
util_version_test(memcached_st
*memc
)
4450 if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4451 test_true(if_successful
== true);
4453 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4455 // We expect failure
4458 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4459 fprintf(stderr
, "\nDumping Server Information\n\n");
4460 memcached_server_fn callbacks
[1];
4462 callbacks
[0]= dump_server_information
;
4463 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4464 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4466 test_true(if_successful
== false);
4468 memcached_server_instance_st instance
=
4469 memcached_server_instance_by_position(memc
, 0);
4471 memcached_version(memc
);
4473 // We only use one binary when we test, so this should be just fine.
4474 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4475 test_true(if_successful
== true);
4477 if (instance
->micro_version
> 0)
4478 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4479 else if (instance
->minor_version
> 0)
4480 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4481 else if (instance
->major_version
> 0)
4482 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4484 test_true(if_successful
== true);
4486 if (instance
->micro_version
> 0)
4487 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4488 else if (instance
->minor_version
> 0)
4489 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4490 else if (instance
->major_version
> 0)
4491 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4493 test_true(if_successful
== false);
4495 return TEST_SUCCESS
;
4498 static test_return_t
ping_test(memcached_st
*memc
)
4500 memcached_return_t rc
;
4501 memcached_server_instance_st instance
=
4502 memcached_server_instance_by_position(memc
, 0);
4504 // Test both the version that returns a code, and the one that does not.
4505 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4506 memcached_server_port(instance
), NULL
));
4508 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4509 memcached_server_port(instance
), &rc
));
4511 test_true(rc
== MEMCACHED_SUCCESS
);
4513 return TEST_SUCCESS
;
4517 static test_return_t
replication_set_test(memcached_st
*memc
)
4519 memcached_return_t rc
;
4520 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4521 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
4523 rc
= memcached_set(memc
, "bubba", 5, "0", 1, 0, 0);
4524 test_true(rc
== MEMCACHED_SUCCESS
);
4527 ** We are using the quiet commands to store the replicas, so we need
4528 ** to ensure that all of them are processed before we can continue.
4529 ** In the test we go directly from storing the object to trying to
4530 ** receive the object from all of the different servers, so we
4531 ** could end up in a race condition (the memcached server hasn't yet
4532 ** processed the quiet command from the replication set when it process
4533 ** the request from the other client (created by the clone)). As a
4534 ** workaround for that we call memcached_quit to send the quit command
4535 ** to the server and wait for the response ;-) If you use the test code
4536 ** as an example for your own code, please note that you shouldn't need
4539 memcached_quit(memc
);
4542 ** "bubba" should now be stored on all of our servers. We don't have an
4543 ** easy to use API to address each individual server, so I'll just iterate
4544 ** through a bunch of "master keys" and I should most likely hit all of the
4547 for (int x
= 'a'; x
<= 'z'; ++x
)
4549 char key
[2]= { [0]= (char)x
};
4552 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
4554 test_true(rc
== MEMCACHED_SUCCESS
);
4555 test_true(val
!= NULL
);
4559 memcached_free(memc_clone
);
4561 return TEST_SUCCESS
;
4564 static test_return_t
replication_get_test(memcached_st
*memc
)
4566 memcached_return_t rc
;
4569 * Don't do the following in your code. I am abusing the internal details
4570 * within the library, and this is not a supported interface.
4571 * This is to verify correct behavior in the library
4573 for (uint32_t host
= 0; host
< memcached_server_count(memc
); ++host
)
4575 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4576 memcached_server_instance_st instance
=
4577 memcached_server_instance_by_position(memc_clone
, host
);
4579 ((memcached_server_write_instance_st
)instance
)->port
= 0;
4581 for (int x
= 'a'; x
<= 'z'; ++x
)
4583 char key
[2]= { [0]= (char)x
};
4586 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
4588 test_true(rc
== MEMCACHED_SUCCESS
);
4589 test_true(val
!= NULL
);
4593 memcached_free(memc_clone
);
4596 return TEST_SUCCESS
;
4599 static test_return_t
replication_mget_test(memcached_st
*memc
)
4601 memcached_return_t rc
;
4602 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4603 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
4605 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
4606 size_t len
[]= { 5, 4, 4, 4 };
4608 for (size_t x
= 0; x
< 4; ++x
)
4610 rc
= memcached_set(memc
, keys
[x
], len
[x
], "0", 1, 0, 0);
4611 test_true(rc
== MEMCACHED_SUCCESS
);
4615 ** We are using the quiet commands to store the replicas, so we need
4616 ** to ensure that all of them are processed before we can continue.
4617 ** In the test we go directly from storing the object to trying to
4618 ** receive the object from all of the different servers, so we
4619 ** could end up in a race condition (the memcached server hasn't yet
4620 ** processed the quiet command from the replication set when it process
4621 ** the request from the other client (created by the clone)). As a
4622 ** workaround for that we call memcached_quit to send the quit command
4623 ** to the server and wait for the response ;-) If you use the test code
4624 ** as an example for your own code, please note that you shouldn't need
4627 memcached_quit(memc
);
4630 * Don't do the following in your code. I am abusing the internal details
4631 * within the library, and this is not a supported interface.
4632 * This is to verify correct behavior in the library
4634 memcached_result_st result_obj
;
4635 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; host
++)
4637 memcached_st
*new_clone
= memcached_clone(NULL
, memc
);
4638 memcached_server_instance_st instance
=
4639 memcached_server_instance_by_position(new_clone
, host
);
4640 ((memcached_server_write_instance_st
)instance
)->port
= 0;
4642 for (int x
= 'a'; x
<= 'z'; ++x
)
4644 char key
[2]= { [0]= (char)x
, [1]= 0 };
4646 rc
= memcached_mget_by_key(new_clone
, key
, 1, keys
, len
, 4);
4647 test_true(rc
== MEMCACHED_SUCCESS
);
4649 memcached_result_st
*results
= memcached_result_create(new_clone
, &result_obj
);
4653 while ((results
= memcached_fetch_result(new_clone
, &result_obj
, &rc
)) != NULL
)
4657 test_true(hits
== 4);
4658 memcached_result_free(&result_obj
);
4661 memcached_free(new_clone
);
4664 memcached_free(memc_clone
);
4666 return TEST_SUCCESS
;
4669 static test_return_t
replication_randomize_mget_test(memcached_st
*memc
)
4671 memcached_result_st result_obj
;
4672 memcached_return_t rc
;
4673 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4674 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 3);
4675 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ
, 1);
4677 const char *keys
[]= { "key1", "key2", "key3", "key4", "key5", "key6", "key7" };
4678 size_t len
[]= { 4, 4, 4, 4, 4, 4, 4 };
4680 for (size_t x
= 0; x
< 7; ++x
)
4682 rc
= memcached_set(memc
, keys
[x
], len
[x
], "1", 1, 0, 0);
4683 test_true(rc
== MEMCACHED_SUCCESS
);
4686 memcached_quit(memc
);
4688 for (size_t x
= 0; x
< 7; ++x
)
4690 const char key
[2]= { [0]= (const char)x
};
4692 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 7);
4693 test_true(rc
== MEMCACHED_SUCCESS
);
4695 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4699 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4703 test_true(hits
== 7);
4704 memcached_result_free(&result_obj
);
4706 memcached_free(memc_clone
);
4707 return TEST_SUCCESS
;
4710 static test_return_t
replication_delete_test(memcached_st
*memc
)
4712 memcached_return_t rc
;
4713 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4714 /* Delete the items from all of the servers except 1 */
4715 uint64_t repl
= memcached_behavior_get(memc
,
4716 MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
4717 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, --repl
);
4719 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
4720 size_t len
[]= { 5, 4, 4, 4 };
4722 for (size_t x
= 0; x
< 4; ++x
)
4724 rc
= memcached_delete_by_key(memc
, keys
[0], len
[0], keys
[x
], len
[x
], 0);
4725 test_true(rc
== MEMCACHED_SUCCESS
);
4729 * Don't do the following in your code. I am abusing the internal details
4730 * within the library, and this is not a supported interface.
4731 * This is to verify correct behavior in the library
4733 uint32_t hash
= memcached_generate_hash(memc
, keys
[0], len
[0]);
4734 for (uint32_t x
= 0; x
< (repl
+ 1); ++x
)
4736 memcached_server_instance_st instance
=
4737 memcached_server_instance_by_position(memc_clone
, x
);
4739 ((memcached_server_write_instance_st
)instance
)->port
= 0;
4740 if (++hash
== memc_clone
->number_of_hosts
)
4744 memcached_result_st result_obj
;
4745 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; ++host
)
4747 for (size_t x
= 'a'; x
<= 'z'; ++x
)
4749 const char key
[2]= { [0]= (const char)x
};
4751 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 4);
4752 test_true(rc
== MEMCACHED_SUCCESS
);
4754 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4758 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4762 test_true(hits
== 4);
4763 memcached_result_free(&result_obj
);
4766 memcached_free(memc_clone
);
4768 return TEST_SUCCESS
;
4772 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4776 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4777 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4778 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4779 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4780 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4781 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4782 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4783 #ifdef HAVE_HSIEH_HASH
4784 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4786 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4787 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4788 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4790 return TEST_SUCCESS
;
4794 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4796 memcached_return_t expected_rc
= MEMCACHED_FAILURE
;
4797 #ifdef HAVE_HSIEH_HASH
4798 expected_rc
= MEMCACHED_SUCCESS
;
4800 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4801 (uint64_t)MEMCACHED_HASH_HSIEH
);
4802 test_true(rc
== expected_rc
);
4804 return TEST_SUCCESS
;
4807 static test_return_t
one_at_a_time_run (memcached_st
*memc
__attribute__((unused
)))
4812 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4816 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
);
4817 test_true(one_at_a_time_values
[x
] == hash_val
);
4820 return TEST_SUCCESS
;
4823 static test_return_t
md5_run (memcached_st
*memc
__attribute__((unused
)))
4828 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4832 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4833 test_true(md5_values
[x
] == hash_val
);
4836 return TEST_SUCCESS
;
4839 static test_return_t
crc_run (memcached_st
*memc
__attribute__((unused
)))
4844 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4848 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4849 test_true(crc_values
[x
] == hash_val
);
4852 return TEST_SUCCESS
;
4855 static test_return_t
fnv1_64_run (memcached_st
*memc
__attribute__((unused
)))
4860 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4864 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4865 test_true(fnv1_64_values
[x
] == hash_val
);
4868 return TEST_SUCCESS
;
4871 static test_return_t
fnv1a_64_run (memcached_st
*memc
__attribute__((unused
)))
4876 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4880 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4881 test_true(fnv1a_64_values
[x
] == hash_val
);
4884 return TEST_SUCCESS
;
4887 static test_return_t
fnv1_32_run (memcached_st
*memc
__attribute__((unused
)))
4893 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4897 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4898 test_true(fnv1_32_values
[x
] == hash_val
);
4901 return TEST_SUCCESS
;
4904 static test_return_t
fnv1a_32_run (memcached_st
*memc
__attribute__((unused
)))
4909 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4913 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4914 test_true(fnv1a_32_values
[x
] == hash_val
);
4917 return TEST_SUCCESS
;
4920 static test_return_t
hsieh_run (memcached_st
*memc
__attribute__((unused
)))
4925 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4929 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4930 test_true(hsieh_values
[x
] == hash_val
);
4933 return TEST_SUCCESS
;
4936 static test_return_t
murmur_run (memcached_st
*memc
__attribute__((unused
)))
4938 #ifdef WORDS_BIGENDIAN
4939 return TEST_SKIPPED
;
4944 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4948 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
4949 test_true(murmur_values
[x
] == hash_val
);
4952 return TEST_SUCCESS
;
4956 static test_return_t
jenkins_run (memcached_st
*memc
__attribute__((unused
)))
4962 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4966 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4967 test_true(jenkins_values
[x
] == hash_val
);
4970 return TEST_SUCCESS
;
4973 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *context
)
4976 return libhashkit_md5(string
, string_length
);
4979 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *context
)
4982 return libhashkit_crc32(string
, string_length
);
4985 static test_return_t
memcached_get_hashkit_test (memcached_st
*memc
)
4989 const hashkit_st
*kit
;
4991 hashkit_return_t hash_rc
;
4993 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};
4994 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};
4996 kit
= memcached_get_hashkit(memc
);
4998 hashkit_clone(&new_kit
, kit
);
4999 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
);
5000 test_true(hash_rc
== HASHKIT_SUCCESS
);
5002 memcached_set_hashkit(memc
, &new_kit
);
5005 Verify Setting the hash.
5007 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5011 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
5012 test_true(md5_values
[x
] == hash_val
);
5017 Now check memcached_st.
5019 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5023 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
5024 test_true(md5_hosts
[x
] == hash_val
);
5027 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
);
5028 test_true(hash_rc
== HASHKIT_SUCCESS
);
5030 memcached_set_hashkit(memc
, &new_kit
);
5033 Verify Setting the hash.
5035 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5039 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
5040 test_true(crc_values
[x
] == hash_val
);
5043 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5047 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
5048 test_true(crc_hosts
[x
] == hash_val
);
5051 return TEST_SUCCESS
;
5055 Test case adapted from John Gorman <johngorman2@gmail.com>
5057 We are testing the error condition when we connect to a server via memcached_get()
5058 but find that the server is not available.
5060 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*memc
)
5063 memcached_st
*tl_memc_h
;
5064 memcached_server_st
*servers
;
5066 const char *key
= "MemcachedLives";
5069 memcached_return rc
;
5073 tl_memc_h
= memcached_create(NULL
);
5074 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
5075 memcached_server_push(tl_memc_h
, servers
);
5076 memcached_server_list_free(servers
);
5078 // See if memcached is reachable.
5079 value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
5082 test_true(len
== 0);
5083 test_false(rc
== MEMCACHED_SUCCESS
);
5085 memcached_free(tl_memc_h
);
5087 return TEST_SUCCESS
;
5091 We connect to a server which exists, but search for a key that does not exist.
5093 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
5095 const char *key
= "MemcachedKeyNotEXIST";
5098 memcached_return rc
;
5101 // See if memcached is reachable.
5102 value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
5105 test_true(len
== 0);
5106 test_true(rc
== MEMCACHED_NOTFOUND
);
5108 return TEST_SUCCESS
;
5112 Test case adapted from John Gorman <johngorman2@gmail.com>
5114 We are testing the error condition when we connect to a server via memcached_get_by_key()
5115 but find that the server is not available.
5117 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
5120 memcached_st
*tl_memc_h
;
5121 memcached_server_st
*servers
;
5123 const char *key
= "MemcachedLives";
5126 memcached_return rc
;
5130 tl_memc_h
= memcached_create(NULL
);
5131 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
5132 memcached_server_push(tl_memc_h
, servers
);
5133 memcached_server_list_free(servers
);
5135 // See if memcached is reachable.
5136 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
5139 test_true(len
== 0);
5140 test_false(rc
== MEMCACHED_SUCCESS
);
5142 memcached_free(tl_memc_h
);
5144 return TEST_SUCCESS
;
5148 We connect to a server which exists, but search for a key that does not exist.
5150 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
5152 const char *key
= "MemcachedKeyNotEXIST";
5155 memcached_return rc
;
5158 // See if memcached is reachable.
5159 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
5162 test_true(len
== 0);
5163 test_true(rc
== MEMCACHED_NOTFOUND
);
5165 return TEST_SUCCESS
;
5169 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*trash
)
5171 memcached_return_t rc
;
5174 memcached_server_st
*server_pool
;
5179 memc
= memcached_create(NULL
);
5182 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5183 test_true(rc
== MEMCACHED_SUCCESS
);
5185 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5186 test_true(value
== 1);
5188 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
) == MEMCACHED_SUCCESS
);
5189 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
);
5192 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");
5193 memcached_server_push(memc
, server_pool
);
5195 /* verify that the server list was parsed okay. */
5196 test_true(memcached_server_count(memc
) == 8);
5197 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5198 test_true(server_pool
[0].port
== 11211);
5199 test_true(server_pool
[0].weight
== 600);
5200 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5201 test_true(server_pool
[2].port
== 11211);
5202 test_true(server_pool
[2].weight
== 200);
5203 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5204 test_true(server_pool
[7].port
== 11211);
5205 test_true(server_pool
[7].weight
== 100);
5207 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5208 * us test the boundary wraparound.
5210 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5212 /* verify the standard ketama set. */
5213 for (x
= 0; x
< 99; x
++)
5215 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
5216 memcached_server_instance_st instance
=
5217 memcached_server_instance_by_position(memc
, server_idx
);
5218 const char *hostname
= memcached_server_name(instance
);
5220 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
5223 memcached_server_list_free(server_pool
);
5224 memcached_free(memc
);
5226 return TEST_SUCCESS
;
5229 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*trash
)
5231 memcached_return_t rc
;
5234 memcached_server_st
*server_pool
;
5239 memc
= memcached_create(NULL
);
5242 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5243 test_true(rc
== MEMCACHED_SUCCESS
);
5245 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5246 test_true(value
== 1);
5248 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
5249 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
);
5251 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");
5252 memcached_server_push(memc
, server_pool
);
5254 /* verify that the server list was parsed okay. */
5255 test_true(memcached_server_count(memc
) == 8);
5256 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5257 test_true(server_pool
[0].port
== 11211);
5258 test_true(server_pool
[0].weight
== 600);
5259 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5260 test_true(server_pool
[2].port
== 11211);
5261 test_true(server_pool
[2].weight
== 200);
5262 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5263 test_true(server_pool
[7].port
== 11211);
5264 test_true(server_pool
[7].weight
== 100);
5266 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5267 * us test the boundary wraparound.
5269 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5271 /* verify the standard ketama set. */
5272 for (x
= 0; x
< 99; x
++)
5274 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
5276 memcached_server_instance_st instance
=
5277 memcached_server_instance_by_position(memc
, server_idx
);
5279 const char *hostname
= memcached_server_name(instance
);
5281 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
5284 memcached_server_list_free(server_pool
);
5285 memcached_free(memc
);
5287 return TEST_SUCCESS
;
5290 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5292 test_return_t test_rc
;
5293 test_rc
= pre_binary(memc
);
5295 if (test_rc
!= TEST_SUCCESS
)
5298 memcached_return_t ret
;
5299 const char *key
= "regression_bug_434484";
5300 size_t keylen
= strlen(key
);
5302 ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5303 test_true(ret
== MEMCACHED_NOTSTORED
);
5305 size_t size
= 2048 * 1024;
5306 void *data
= calloc(1, size
);
5307 test_true(data
!= NULL
);
5308 ret
= memcached_set(memc
, key
, keylen
, data
, size
, 0, 0);
5309 test_true(ret
== MEMCACHED_E2BIG
);
5312 return TEST_SUCCESS
;
5315 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5317 test_return_t test_rc
;
5318 test_rc
= pre_binary(memc
);
5320 if (test_rc
!= TEST_SUCCESS
)
5323 memcached_return_t rc
;
5325 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5328 * I only want to hit only _one_ server so I know the number of requests I'm
5329 * sending in the pipleine to the server. Let's try to do a multiget of
5330 * 1024 (that should satisfy most users don't you think?). Future versions
5331 * will include a mget_execute function call if you need a higher number.
5333 uint32_t number_of_hosts
= memcached_server_count(memc
);
5334 memc
->number_of_hosts
= 1;
5335 const size_t max_keys
= 1024;
5336 char **keys
= calloc(max_keys
, sizeof(char*));
5337 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5339 for (size_t x
= 0; x
< max_keys
; ++x
)
5343 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5345 test_true(keys
[x
] != NULL
);
5349 * Run two times.. the first time we should have 100% cache miss,
5350 * and the second time we should have 100% cache hits
5352 for (size_t y
= 0; y
< 2; y
++)
5354 rc
= memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
);
5355 test_true(rc
== MEMCACHED_SUCCESS
);
5356 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5360 /* The first iteration should give me a 100% cache miss. verify that*/
5361 char blob
[1024]= { 0 };
5363 test_true(counter
== 0);
5365 for (size_t x
= 0; x
< max_keys
; ++x
)
5367 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5368 blob
, sizeof(blob
), 0, 0);
5369 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5374 /* Verify that we received all of the key/value pairs */
5375 test_true(counter
== max_keys
);
5379 /* Release allocated resources */
5380 for (size_t x
= 0; x
< max_keys
; ++x
)
5387 memc
->number_of_hosts
= number_of_hosts
;
5389 return TEST_SUCCESS
;
5392 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5394 memcached_return_t rc
;
5395 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5396 test_true(rc
== MEMCACHED_SUCCESS
);
5398 return regression_bug_434843(memc
);
5401 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5403 memcached_return_t rc
;
5404 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5405 test_true(rc
== MEMCACHED_SUCCESS
);
5407 char *bytes
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5408 test_true(rc
== MEMCACHED_SUCCESS
);
5409 test_true(bytes
!= NULL
);
5410 char *bytes_read
= memcached_stat_get_value(memc
, memc_stat
,
5412 test_true(rc
== MEMCACHED_SUCCESS
);
5413 test_true(bytes_read
!= NULL
);
5415 char *bytes_written
= memcached_stat_get_value(memc
, memc_stat
,
5416 "bytes_written", &rc
);
5417 test_true(rc
== MEMCACHED_SUCCESS
);
5418 test_true(bytes_written
!= NULL
);
5420 test_true(strcmp(bytes
, bytes_read
) != 0);
5421 test_true(strcmp(bytes
, bytes_written
) != 0);
5423 /* Release allocated resources */
5426 free(bytes_written
);
5427 memcached_stat_free(NULL
, memc_stat
);
5429 return TEST_SUCCESS
;
5433 * The test case isn't obvious so I should probably document why
5434 * it works the way it does. Bug 442914 was caused by a bug
5435 * in the logic in memcached_purge (it did not handle the case
5436 * where the number of bytes sent was equal to the watermark).
5437 * In this test case, create messages so that we hit that case
5438 * and then disable noreply mode and issue a new command to
5439 * verify that it isn't stuck. If we change the format for the
5440 * delete command or the watermarks, we need to update this
5443 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5445 memcached_return_t rc
;
5446 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
5447 test_true(rc
== MEMCACHED_SUCCESS
);
5448 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5450 uint32_t number_of_hosts
= memcached_server_count(memc
);
5451 memc
->number_of_hosts
= 1;
5456 for (uint32_t x
= 0; x
< 250; ++x
)
5458 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5459 rc
= memcached_delete(memc
, k
, len
, 0);
5460 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5463 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5466 rc
= memcached_delete(memc
, k
, len
, 0);
5467 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5469 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0);
5470 test_true(rc
== MEMCACHED_SUCCESS
);
5471 rc
= memcached_delete(memc
, k
, len
, 0);
5472 test_true(rc
== MEMCACHED_NOTFOUND
);
5474 memc
->number_of_hosts
= number_of_hosts
;
5476 return TEST_SUCCESS
;
5479 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5481 memcached_server_instance_st instance_one
;
5482 memcached_server_instance_st instance_two
;
5484 if (memcached_server_count(memc
) < 3 || pre_replication(memc
) != TEST_SUCCESS
)
5485 return TEST_SKIPPED
;
5487 memcached_return_t rc
;
5489 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2);
5490 test_true(rc
== MEMCACHED_SUCCESS
);
5492 const size_t max_keys
= 100;
5493 char **keys
= calloc(max_keys
, sizeof(char*));
5494 size_t *key_length
= calloc(max_keys
, sizeof(size_t));
5496 for (size_t x
= 0; x
< max_keys
; ++x
)
5500 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5502 test_true(keys
[x
] != NULL
);
5503 rc
= memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0);
5504 test_true(rc
== MEMCACHED_SUCCESS
);
5508 ** We are using the quiet commands to store the replicas, so we need
5509 ** to ensure that all of them are processed before we can continue.
5510 ** In the test we go directly from storing the object to trying to
5511 ** receive the object from all of the different servers, so we
5512 ** could end up in a race condition (the memcached server hasn't yet
5513 ** processed the quiet command from the replication set when it process
5514 ** the request from the other client (created by the clone)). As a
5515 ** workaround for that we call memcached_quit to send the quit command
5516 ** to the server and wait for the response ;-) If you use the test code
5517 ** as an example for your own code, please note that you shouldn't need
5520 memcached_quit(memc
);
5522 /* Verify that all messages are stored, and we didn't stuff too much
5525 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5526 test_true(rc
== MEMCACHED_SUCCESS
);
5529 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5530 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5531 /* Verify that we received all of the key/value pairs */
5532 test_true(counter
== max_keys
);
5534 memcached_quit(memc
);
5536 * Don't do the following in your code. I am abusing the internal details
5537 * within the library, and this is not a supported interface.
5538 * This is to verify correct behavior in the library. Fake that two servers
5541 instance_one
= memcached_server_instance_by_position(memc
, 0);
5542 instance_two
= memcached_server_instance_by_position(memc
, 2);
5543 in_port_t port0
= instance_one
->port
;
5544 in_port_t port2
= instance_two
->port
;
5546 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5547 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5549 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5550 test_true(rc
== MEMCACHED_SUCCESS
);
5553 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5554 test_true(counter
== (unsigned int)max_keys
);
5556 /* restore the memc handle */
5557 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5558 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5560 memcached_quit(memc
);
5562 /* Remove half of the objects */
5563 for (size_t x
= 0; x
< max_keys
; ++x
)
5567 rc
= memcached_delete(memc
, keys
[x
], key_length
[x
], 0);
5568 test_true(rc
== MEMCACHED_SUCCESS
);
5572 memcached_quit(memc
);
5573 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5574 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5576 /* now retry the command, this time we should have cache misses */
5577 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5578 test_true(rc
== MEMCACHED_SUCCESS
);
5581 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5582 test_true(counter
== (unsigned int)(max_keys
>> 1));
5584 /* Release allocated resources */
5585 for (size_t x
= 0; x
< max_keys
; ++x
)
5592 /* restore the memc handle */
5593 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5594 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5596 return TEST_SUCCESS
;
5599 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5601 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5602 test_true(memc_clone
!= NULL
);
5603 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5605 memcached_server_instance_st instance
=
5606 memcached_server_instance_by_position(memc_clone
, 0);
5608 if (instance
->major_version
> 1 ||
5609 (instance
->major_version
== 1 &&
5610 instance
->minor_version
> 2))
5612 /* Binary protocol doesn't support deferred delete */
5613 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5614 test_true(bin_clone
!= NULL
);
5615 test_true(memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1) == MEMCACHED_SUCCESS
);
5616 test_true(memcached_delete(bin_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5617 memcached_free(bin_clone
);
5619 memcached_quit(memc_clone
);
5621 /* If we know the server version, deferred delete should fail
5622 * with invalid arguments */
5623 test_true(memcached_delete(memc_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5625 /* If we don't know the server version, we should get a protocol error */
5626 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5628 /* but there is a bug in some of the memcached servers (1.4) that treats
5629 * the counter as noreply so it doesn't send the proper error message
5631 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5633 /* And buffered mode should be disabled and we should get protocol error */
5634 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5635 rc
= memcached_delete(memc
, "foo", 3, 1);
5636 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5638 /* Same goes for noreply... */
5639 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1) == MEMCACHED_SUCCESS
);
5640 rc
= memcached_delete(memc
, "foo", 3, 1);
5641 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5643 /* but a normal request should go through (and be buffered) */
5644 test_true((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_BUFFERED
);
5645 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
5647 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0) == MEMCACHED_SUCCESS
);
5648 /* unbuffered noreply should be success */
5649 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_SUCCESS
);
5650 /* unbuffered with reply should be not found... */
5651 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0) == MEMCACHED_SUCCESS
);
5652 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_NOTFOUND
);
5655 memcached_free(memc_clone
);
5656 return TEST_SUCCESS
;
5660 /* Test memcached_server_get_last_disconnect
5661 * For a working server set, shall be NULL
5662 * For a set of non existing server, shall not be NULL
5664 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5666 memcached_return_t rc
;
5667 memcached_server_instance_st disconnected_server
;
5669 /* With the working set of server */
5670 const char *key
= "marmotte";
5671 const char *value
= "milka";
5673 memcached_reset_last_disconnected_server(memc
);
5674 rc
= memcached_set(memc
, key
, strlen(key
),
5675 value
, strlen(value
),
5676 (time_t)0, (uint32_t)0);
5677 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5679 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5680 test_true(disconnected_server
== NULL
);
5682 /* With a non existing server */
5684 memcached_server_st
*servers
;
5686 const char *server_list
= "localhost:9";
5688 servers
= memcached_servers_parse(server_list
);
5690 mine
= memcached_create(NULL
);
5691 rc
= memcached_server_push(mine
, servers
);
5692 test_true(rc
== MEMCACHED_SUCCESS
);
5693 memcached_server_list_free(servers
);
5696 rc
= memcached_set(mine
, key
, strlen(key
),
5697 value
, strlen(value
),
5698 (time_t)0, (uint32_t)0);
5699 test_true(rc
!= MEMCACHED_SUCCESS
);
5701 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5702 if (disconnected_server
== NULL
)
5704 fprintf(stderr
, "RC %s\n", memcached_strerror(mine
, rc
));
5707 test_true(disconnected_server
!= NULL
);
5708 test_true(memcached_server_port(disconnected_server
)== 9);
5709 test_true(strncmp(memcached_server_name(disconnected_server
),"localhost",9) == 0);
5711 memcached_quit(mine
);
5712 memcached_free(mine
);
5714 return TEST_SUCCESS
;
5717 static test_return_t
test_verbosity(memcached_st
*memc
)
5719 memcached_verbosity(memc
, 3);
5721 return TEST_SUCCESS
;
5724 static test_return_t
test_server_failure(memcached_st
*memc
)
5726 memcached_st
*local_memc
;
5727 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
5729 local_memc
= memcached_create(NULL
);
5731 memcached_server_add(local_memc
, memcached_server_name(instance
), memcached_server_port(instance
));
5732 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 2);
5734 uint32_t server_count
= memcached_server_count(local_memc
);
5736 test_true(server_count
== 1);
5738 // Disable the server
5739 instance
= memcached_server_instance_by_position(local_memc
, 0);
5740 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 2;
5742 memcached_return_t rc
;
5743 rc
= memcached_set(local_memc
, "foo", strlen("foo"),
5745 (time_t)0, (uint32_t)0);
5746 test_true(rc
== MEMCACHED_SERVER_MARKED_DEAD
);
5748 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5749 rc
= memcached_set(local_memc
, "foo", strlen("foo"),
5751 (time_t)0, (uint32_t)0);
5752 test_true(rc
== MEMCACHED_SUCCESS
);
5755 memcached_free(local_memc
);
5757 return TEST_SUCCESS
;
5760 static test_return_t
test_cull_servers(memcached_st
*memc
)
5762 uint32_t count
= memcached_server_count(memc
);
5764 // Do not do this in your code, it is not supported.
5765 memc
->servers
[1].state
.is_dead
= true;
5766 memc
->state
.is_time_for_rebuild
= true;
5768 uint32_t new_count
= memcached_server_count(memc
);
5769 test_true(count
== new_count
);
5772 test_true(count
== new_count
+ 1 );
5775 return TEST_SUCCESS
;
5779 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5780 const char *key
, size_t key_length
,
5781 const char *value
, size_t value_length
,
5791 return MEMCACHED_SUCCESS
;
5794 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5796 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5797 test_true(rc
== MEMCACHED_SUCCESS
);
5799 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5800 test_true(rc
== MEMCACHED_SUCCESS
);
5802 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5803 test_true(rc
== MEMCACHED_SUCCESS
);
5805 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5806 test_true(rc
== MEMCACHED_SUCCESS
);
5808 return TEST_SUCCESS
;
5812 * This test ensures that the failure counter isn't incremented during
5813 * normal termination of the memcached instance.
5815 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5817 memcached_return_t rc
;
5818 memcached_server_instance_st instance
;
5820 /* Set value to force connection to the server */
5821 const char *key
= "marmotte";
5822 const char *value
= "milka";
5825 * Please note that I'm abusing the internal structures in libmemcached
5826 * in a non-portable way and you shouldn't be doing this. I'm only
5827 * doing this in order to verify that the library works the way it should
5829 uint32_t number_of_hosts
= memcached_server_count(memc
);
5830 memc
->number_of_hosts
= 1;
5832 /* Ensure that we are connected to the server by setting a value */
5833 rc
= memcached_set(memc
, key
, strlen(key
),
5834 value
, strlen(value
),
5835 (time_t)0, (uint32_t)0);
5836 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5839 instance
= memcached_server_instance_by_position(memc
, 0);
5840 /* The test is to see that the memcached_quit doesn't increase the
5841 * the server failure conter, so let's ensure that it is zero
5842 * before sending quit
5844 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5846 memcached_quit(memc
);
5848 /* Verify that it memcached_quit didn't increment the failure counter
5849 * Please note that this isn't bullet proof, because an error could
5852 test_true(instance
->server_failure_counter
== 0);
5854 /* restore the instance */
5855 memc
->number_of_hosts
= number_of_hosts
;
5857 return TEST_SUCCESS
;
5864 * Test that ensures mget_execute does not end into recursive calls that finally fails
5866 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5868 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5869 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5870 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5871 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5872 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5875 return TEST_SKIPPED
; // My MAC can't handle this test
5879 * I only want to hit _one_ server so I know the number of requests I'm
5880 * sending in the pipeline.
5882 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5883 memc
->number_of_hosts
= 1;
5884 size_t max_keys
= 20480;
5887 char **keys
= calloc(max_keys
, sizeof(char*));
5888 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5890 /* First add all of the items.. */
5892 char blob
[1024]= { 0 };
5893 memcached_return rc
;
5894 for (size_t x
= 0; x
< max_keys
; ++x
)
5897 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5899 assert(keys
[x
] != NULL
);
5900 rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5902 if (rc
== MEMCACHED_SERVER_MARKED_DEAD
)
5904 break; // We are out of business
5907 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
); // MEMCACHED_TIMEOUT <-- only observed on OSX
5909 if (rc
== MEMCACHED_TIMEOUT
&& slept
== false)
5912 sleep(1);// We will try to sleep
5915 else if (rc
== MEMCACHED_TIMEOUT
&& slept
== true)
5917 // We failed to send everything.
5922 if (rc
!= MEMCACHED_SERVER_MARKED_DEAD
)
5925 /* Try to get all of them with a large multiget */
5927 memcached_execute_function callbacks
[1]= { [0]= &callback_counter
};
5928 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5929 (size_t)max_keys
, callbacks
, &counter
, 1);
5931 assert(rc
== MEMCACHED_SUCCESS
);
5932 char* the_value
= NULL
;
5933 char the_key
[MEMCACHED_MAX_KEY
];
5934 size_t the_key_length
;
5935 size_t the_value_length
;
5939 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5941 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5947 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5950 assert(rc
== MEMCACHED_END
);
5952 /* Verify that we got all of the items */
5953 assert(counter
== max_keys
);
5956 /* Release all allocated resources */
5957 for (size_t x
= 0; x
< max_keys
; ++x
)
5964 memc
->number_of_hosts
= number_of_hosts
;
5966 return TEST_SUCCESS
;
5969 static test_return_t
regression_bug_583031(memcached_st
*unused
)
5973 memcached_st
*memc
= memcached_create(NULL
);
5975 memcached_server_add(memc
, "10.2.3.4", 11211);
5977 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5978 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5979 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5980 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5981 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5982 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5984 memcached_return_t rc
;
5988 (void)memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5990 test_true_got(rc
== MEMCACHED_TIMEOUT
, memcached_strerror(NULL
, rc
));
5992 memcached_free(memc
);
5994 return TEST_SUCCESS
;
5997 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5999 fprintf(stderr
, "Iteration #%u: ", it
);
6001 if(error
== MEMCACHED_ERRNO
)
6003 fprintf(stderr
, "system error %d from %s: %s\n",
6004 errno
, what
, strerror(errno
));
6008 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
6009 memcached_strerror(mc
, error
));
6013 #define TEST_CONSTANT_CREATION 200
6015 static test_return_t
regression_bug_(memcached_st
*memc
)
6017 const char *remote_server
;
6020 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
6022 return TEST_SKIPPED
;
6025 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
6027 memcached_st
* mc
= memcached_create(NULL
);
6028 memcached_return rc
;
6030 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
6031 if (rc
!= MEMCACHED_SUCCESS
)
6033 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6036 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
6037 if (rc
!= MEMCACHED_SUCCESS
)
6039 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6042 rc
= memcached_server_add(mc
, remote_server
, 0);
6043 if (rc
!= MEMCACHED_SUCCESS
)
6045 memcached_die(mc
, rc
, "memcached_server_add", x
);
6048 const char *set_key
= "akey";
6049 const size_t set_key_len
= strlen(set_key
);
6050 const char *set_value
= "a value";
6051 const size_t set_value_len
= strlen(set_value
);
6053 if (rc
== MEMCACHED_SUCCESS
)
6057 size_t get_value_len
;
6059 uint32_t get_value_flags
;
6061 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
6062 &get_value_flags
, &rc
);
6063 if (rc
!= MEMCACHED_SUCCESS
)
6065 memcached_die(mc
, rc
, "memcached_get", x
);
6071 (get_value_len
!= set_value_len
6072 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
6074 fprintf(stderr
, "Values don't match?\n");
6075 rc
= MEMCACHED_FAILURE
;
6081 rc
= memcached_set(mc
,
6082 set_key
, set_key_len
,
6083 set_value
, set_value_len
,
6087 if (rc
!= MEMCACHED_SUCCESS
)
6089 memcached_die(mc
, rc
, "memcached_set", x
);
6096 if (rc
!= MEMCACHED_SUCCESS
)
6102 return TEST_SUCCESS
;
6106 * Test that the sasl authentication works. We cannot use the default
6107 * pool of servers, because that would require that all servers we want
6108 * to test supports SASL authentication, and that they use the default
6111 static test_return_t
sasl_auth_test(memcached_st
*memc
)
6113 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
6114 memcached_return_t rc
;
6116 rc
= memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
6117 test_true(rc
== MEMCACHED_SUCCESS
);
6118 test_true((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_SUCCESS
);
6119 test_true((rc
= memcached_destroy_sasl_auth_data(memc
)) == MEMCACHED_SUCCESS
);
6120 test_true((rc
= memcached_destroy_sasl_auth_data(memc
)) == MEMCACHED_FAILURE
);
6121 test_true((rc
= memcached_destroy_sasl_auth_data(NULL
)) == MEMCACHED_FAILURE
);
6122 memcached_quit(memc
);
6124 rc
= memcached_set_sasl_auth_data(memc
,
6125 getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
6126 getenv("LIBMEMCACHED_TEST_SASL_SERVER"));
6127 test_true(rc
== MEMCACHED_SUCCESS
);
6129 rc
= memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
6130 test_true(rc
== MEMCACHED_AUTH_FAILURE
);
6131 test_true(memcached_destroy_sasl_auth_data(memc
) == MEMCACHED_SUCCESS
);
6133 memcached_quit(memc
);
6134 return TEST_SUCCESS
;
6137 return TEST_FAILURE
;
6141 /* Clean the server before beginning testing */
6143 {"util_version", 1, (test_callback_fn
)util_version_test
},
6144 {"flush", 0, (test_callback_fn
)flush_test
},
6145 {"init", 0, (test_callback_fn
)init_test
},
6146 {"allocation", 0, (test_callback_fn
)allocation_test
},
6147 {"server_list_null_test", 0, (test_callback_fn
)server_list_null_test
},
6148 {"server_unsort", 0, (test_callback_fn
)server_unsort_test
},
6149 {"server_sort", 0, (test_callback_fn
)server_sort_test
},
6150 {"server_sort2", 0, (test_callback_fn
)server_sort2_test
},
6151 {"memcached_server_remove", 0, (test_callback_fn
)memcached_server_remove_test
},
6152 {"clone_test", 0, (test_callback_fn
)clone_test
},
6153 {"connection_test", 0, (test_callback_fn
)connection_test
},
6154 {"callback_test", 0, (test_callback_fn
)callback_test
},
6155 {"userdata_test", 0, (test_callback_fn
)userdata_test
},
6156 {"error", 0, (test_callback_fn
)error_test
},
6157 {"set", 0, (test_callback_fn
)set_test
},
6158 {"set2", 0, (test_callback_fn
)set_test2
},
6159 {"set3", 0, (test_callback_fn
)set_test3
},
6160 {"dump", 1, (test_callback_fn
)dump_test
},
6161 {"add", 1, (test_callback_fn
)add_test
},
6162 {"replace", 1, (test_callback_fn
)replace_test
},
6163 {"delete", 1, (test_callback_fn
)delete_test
},
6164 {"get", 1, (test_callback_fn
)get_test
},
6165 {"get2", 0, (test_callback_fn
)get_test2
},
6166 {"get3", 0, (test_callback_fn
)get_test3
},
6167 {"get4", 0, (test_callback_fn
)get_test4
},
6168 {"partial mget", 0, (test_callback_fn
)get_test5
},
6169 {"stats_servername", 0, (test_callback_fn
)stats_servername_test
},
6170 {"increment", 0, (test_callback_fn
)increment_test
},
6171 {"increment_with_initial", 1, (test_callback_fn
)increment_with_initial_test
},
6172 {"decrement", 0, (test_callback_fn
)decrement_test
},
6173 {"decrement_with_initial", 1, (test_callback_fn
)decrement_with_initial_test
},
6174 {"increment_by_key", 0, (test_callback_fn
)increment_by_key_test
},
6175 {"increment_with_initial_by_key", 1, (test_callback_fn
)increment_with_initial_by_key_test
},
6176 {"decrement_by_key", 0, (test_callback_fn
)decrement_by_key_test
},
6177 {"decrement_with_initial_by_key", 1, (test_callback_fn
)decrement_with_initial_by_key_test
},
6178 {"quit", 0, (test_callback_fn
)quit_test
},
6179 {"mget", 1, (test_callback_fn
)mget_test
},
6180 {"mget_result", 1, (test_callback_fn
)mget_result_test
},
6181 {"mget_result_alloc", 1, (test_callback_fn
)mget_result_alloc_test
},
6182 {"mget_result_function", 1, (test_callback_fn
)mget_result_function
},
6183 {"mget_execute", 1, (test_callback_fn
)mget_execute
},
6184 {"mget_end", 0, (test_callback_fn
)mget_end
},
6185 {"get_stats", 0, (test_callback_fn
)get_stats
},
6186 {"add_host_test", 0, (test_callback_fn
)add_host_test
},
6187 {"add_host_test_1", 0, (test_callback_fn
)add_host_test1
},
6188 {"get_stats_keys", 0, (test_callback_fn
)get_stats_keys
},
6189 {"version_string_test", 0, (test_callback_fn
)version_string_test
},
6190 {"bad_key", 1, (test_callback_fn
)bad_key_test
},
6191 {"memcached_server_cursor", 1, (test_callback_fn
)memcached_server_cursor_test
},
6192 {"read_through", 1, (test_callback_fn
)read_through
},
6193 {"delete_through", 1, (test_callback_fn
)delete_through
},
6194 {"noreply", 1, (test_callback_fn
)noreply_test
},
6195 {"analyzer", 1, (test_callback_fn
)analyzer_test
},
6196 #ifdef HAVE_LIBMEMCACHEDUTIL
6197 {"connectionpool", 1, (test_callback_fn
)connection_pool_test
},
6198 {"ping", 1, (test_callback_fn
)ping_test
},
6200 {"test_get_last_disconnect", 1, (test_callback_fn
)test_get_last_disconnect
},
6201 {"verbosity", 1, (test_callback_fn
)test_verbosity
},
6202 {"test_server_failure", 1, (test_callback_fn
)test_server_failure
},
6203 {"cull_servers", 1, (test_callback_fn
)test_cull_servers
},
6204 {"memcached_stat_execute", 1, (test_callback_fn
)memcached_stat_execute_test
},
6208 test_st behavior_tests
[] ={
6209 {"behavior_test", 0, (test_callback_fn
)behavior_test
},
6210 {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_CORK_test
},
6211 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
6212 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
6216 test_st regression_binary_vs_block
[] ={
6217 {"block add", 1, (test_callback_fn
)block_add_regression
},
6218 {"binary add", 1, (test_callback_fn
)binary_add_regression
},
6222 test_st async_tests
[] ={
6223 {"add", 1, (test_callback_fn
)add_wrapper
},
6227 test_st string_tests
[] ={
6228 {"string static with null", 0, (test_callback_fn
)string_static_null
},
6229 {"string alloc with null", 0, (test_callback_fn
)string_alloc_null
},
6230 {"string alloc with 1K", 0, (test_callback_fn
)string_alloc_with_size
},
6231 {"string alloc with malloc failure", 0, (test_callback_fn
)string_alloc_with_size_toobig
},
6232 {"string append", 0, (test_callback_fn
)string_alloc_append
},
6233 {"string append failure (too big)", 0, (test_callback_fn
)string_alloc_append_toobig
},
6234 {0, 0, (test_callback_fn
)0}
6237 test_st result_tests
[] ={
6238 {"result static", 0, (test_callback_fn
)result_static
},
6239 {"result alloc", 0, (test_callback_fn
)result_alloc
},
6240 {0, 0, (test_callback_fn
)0}
6243 test_st version_1_2_3
[] ={
6244 {"append", 0, (test_callback_fn
)append_test
},
6245 {"prepend", 0, (test_callback_fn
)prepend_test
},
6246 {"cas", 0, (test_callback_fn
)cas_test
},
6247 {"cas2", 0, (test_callback_fn
)cas2_test
},
6248 {"append_binary", 0, (test_callback_fn
)append_binary_test
},
6249 {0, 0, (test_callback_fn
)0}
6252 test_st user_tests
[] ={
6253 {"user_supplied_bug1", 0, (test_callback_fn
)user_supplied_bug1
},
6254 {"user_supplied_bug2", 0, (test_callback_fn
)user_supplied_bug2
},
6255 {"user_supplied_bug3", 0, (test_callback_fn
)user_supplied_bug3
},
6256 {"user_supplied_bug4", 0, (test_callback_fn
)user_supplied_bug4
},
6257 {"user_supplied_bug5", 1, (test_callback_fn
)user_supplied_bug5
},
6258 {"user_supplied_bug6", 1, (test_callback_fn
)user_supplied_bug6
},
6259 {"user_supplied_bug7", 1, (test_callback_fn
)user_supplied_bug7
},
6260 {"user_supplied_bug8", 1, (test_callback_fn
)user_supplied_bug8
},
6261 {"user_supplied_bug9", 1, (test_callback_fn
)user_supplied_bug9
},
6262 {"user_supplied_bug10", 1, (test_callback_fn
)user_supplied_bug10
},
6263 {"user_supplied_bug11", 1, (test_callback_fn
)user_supplied_bug11
},
6264 {"user_supplied_bug12", 1, (test_callback_fn
)user_supplied_bug12
},
6265 {"user_supplied_bug13", 1, (test_callback_fn
)user_supplied_bug13
},
6266 {"user_supplied_bug14", 1, (test_callback_fn
)user_supplied_bug14
},
6267 {"user_supplied_bug15", 1, (test_callback_fn
)user_supplied_bug15
},
6268 {"user_supplied_bug16", 1, (test_callback_fn
)user_supplied_bug16
},
6269 #if !defined(__sun) && !defined(__OpenBSD__)
6271 ** It seems to be something weird with the character sets..
6272 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6273 ** guess I need to find out how this is supposed to work.. Perhaps I need
6274 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6275 ** so just disable the code for now...).
6277 {"user_supplied_bug17", 1, (test_callback_fn
)user_supplied_bug17
},
6279 {"user_supplied_bug18", 1, (test_callback_fn
)user_supplied_bug18
},
6280 {"user_supplied_bug19", 1, (test_callback_fn
)user_supplied_bug19
},
6281 {"user_supplied_bug20", 1, (test_callback_fn
)user_supplied_bug20
},
6282 {"user_supplied_bug21", 1, (test_callback_fn
)user_supplied_bug21
},
6283 {"wrong_failure_counter_test", 1, (test_callback_fn
)wrong_failure_counter_test
},
6284 {0, 0, (test_callback_fn
)0}
6287 test_st replication_tests
[]= {
6288 {"set", 1, (test_callback_fn
)replication_set_test
},
6289 {"get", 0, (test_callback_fn
)replication_get_test
},
6290 {"mget", 0, (test_callback_fn
)replication_mget_test
},
6291 {"delete", 0, (test_callback_fn
)replication_delete_test
},
6292 {"rand_mget", 0, (test_callback_fn
)replication_randomize_mget_test
},
6293 {0, 0, (test_callback_fn
)0}
6297 * The following test suite is used to verify that we don't introduce
6298 * regression bugs. If you want more information about the bug / test,
6299 * you should look in the bug report at
6300 * http://bugs.launchpad.net/libmemcached
6302 test_st regression_tests
[]= {
6303 {"lp:434484", 1, (test_callback_fn
)regression_bug_434484
},
6304 {"lp:434843", 1, (test_callback_fn
)regression_bug_434843
},
6305 {"lp:434843-buffered", 1, (test_callback_fn
)regression_bug_434843_buffered
},
6306 {"lp:421108", 1, (test_callback_fn
)regression_bug_421108
},
6307 {"lp:442914", 1, (test_callback_fn
)regression_bug_442914
},
6308 {"lp:447342", 1, (test_callback_fn
)regression_bug_447342
},
6309 {"lp:463297", 1, (test_callback_fn
)regression_bug_463297
},
6310 {"lp:490486", 1, (test_callback_fn
)regression_bug_490486
},
6311 {"lp:583031", 1, (test_callback_fn
)regression_bug_583031
},
6312 {"lp:?", 1, (test_callback_fn
)regression_bug_
},
6313 {0, 0, (test_callback_fn
)0}
6316 test_st sasl_auth_tests
[]= {
6317 {"sasl_auth", 1, (test_callback_fn
)sasl_auth_test
},
6318 {0, 0, (test_callback_fn
)0}
6321 test_st ketama_compatibility
[]= {
6322 {"libmemcached", 1, (test_callback_fn
)ketama_compatibility_libmemcached
},
6323 {"spymemcached", 1, (test_callback_fn
)ketama_compatibility_spymemcached
},
6324 {0, 0, (test_callback_fn
)0}
6327 test_st generate_tests
[] ={
6328 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6329 {"generate_data", 1, (test_callback_fn
)generate_data
},
6330 {"get_read", 0, (test_callback_fn
)get_read
},
6331 {"delete_generate", 0, (test_callback_fn
)delete_generate
},
6332 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
6333 {"delete_buffer", 0, (test_callback_fn
)delete_buffer_generate
},
6334 {"generate_data", 1, (test_callback_fn
)generate_data
},
6335 {"mget_read", 0, (test_callback_fn
)mget_read
},
6336 {"mget_read_result", 0, (test_callback_fn
)mget_read_result
},
6337 {"mget_read_function", 0, (test_callback_fn
)mget_read_function
},
6338 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6339 {"generate_large_pairs", 1, (test_callback_fn
)generate_large_pairs
},
6340 {"generate_data", 1, (test_callback_fn
)generate_data
},
6341 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
6342 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6343 {0, 0, (test_callback_fn
)0}
6346 test_st consistent_tests
[] ={
6347 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6348 {"generate_data", 1, (test_callback_fn
)generate_data
},
6349 {"get_read", 0, (test_callback_fn
)get_read_count
},
6350 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6351 {0, 0, (test_callback_fn
)0}
6354 test_st consistent_weighted_tests
[] ={
6355 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6356 {"generate_data", 1, (test_callback_fn
)generate_data_with_stats
},
6357 {"get_read", 0, (test_callback_fn
)get_read_count
},
6358 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6359 {0, 0, (test_callback_fn
)0}
6362 test_st hsieh_availability
[] ={
6363 {"hsieh_avaibility_test", 0, (test_callback_fn
)hsieh_avaibility_test
},
6364 {0, 0, (test_callback_fn
)0}
6368 test_st hash_sanity
[] ={
6369 {"hash sanity", 0, (test_callback_fn
)hash_sanity_test
},
6370 {0, 0, (test_callback_fn
)0}
6374 test_st ketama_auto_eject_hosts
[] ={
6375 {"auto_eject_hosts", 1, (test_callback_fn
)auto_eject_hosts
},
6376 {"output_ketama_weighted_keys", 1, (test_callback_fn
)output_ketama_weighted_keys
},
6377 {0, 0, (test_callback_fn
)0}
6380 test_st hash_tests
[] ={
6381 {"one_at_a_time_run", 0, (test_callback_fn
)one_at_a_time_run
},
6382 {"md5", 0, (test_callback_fn
)md5_run
},
6383 {"crc", 0, (test_callback_fn
)crc_run
},
6384 {"fnv1_64", 0, (test_callback_fn
)fnv1_64_run
},
6385 {"fnv1a_64", 0, (test_callback_fn
)fnv1a_64_run
},
6386 {"fnv1_32", 0, (test_callback_fn
)fnv1_32_run
},
6387 {"fnv1a_32", 0, (test_callback_fn
)fnv1a_32_run
},
6388 {"hsieh", 0, (test_callback_fn
)hsieh_run
},
6389 {"murmur", 0, (test_callback_fn
)murmur_run
},
6390 {"jenkis", 0, (test_callback_fn
)jenkins_run
},
6391 {"memcached_get_hashkit", 0, (test_callback_fn
)memcached_get_hashkit_test
},
6392 {0, 0, (test_callback_fn
)0}
6395 test_st error_conditions
[] ={
6396 {"memcached_get_MEMCACHED_ERRNO", 0, (test_callback_fn
)memcached_get_MEMCACHED_ERRNO
},
6397 {"memcached_get_MEMCACHED_NOTFOUND", 0, (test_callback_fn
)memcached_get_MEMCACHED_NOTFOUND
},
6398 {"memcached_get_by_key_MEMCACHED_ERRNO", 0, (test_callback_fn
)memcached_get_by_key_MEMCACHED_ERRNO
},
6399 {"memcached_get_by_key_MEMCACHED_NOTFOUND", 0, (test_callback_fn
)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6400 {0, 0, (test_callback_fn
)0}
6403 collection_st collection
[] ={
6405 {"hash_sanity", 0, 0, hash_sanity
},
6407 {"hsieh_availability", 0, 0, hsieh_availability
},
6408 {"block", 0, 0, tests
},
6409 {"binary", (test_callback_fn
)pre_binary
, 0, tests
},
6410 {"nonblock", (test_callback_fn
)pre_nonblock
, 0, tests
},
6411 {"nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6412 {"settimer", (test_callback_fn
)pre_settimer
, 0, tests
},
6413 {"md5", (test_callback_fn
)pre_md5
, 0, tests
},
6414 {"crc", (test_callback_fn
)pre_crc
, 0, tests
},
6415 {"hsieh", (test_callback_fn
)pre_hsieh
, 0, tests
},
6416 {"jenkins", (test_callback_fn
)pre_jenkins
, 0, tests
},
6417 {"fnv1_64", (test_callback_fn
)pre_hash_fnv1_64
, 0, tests
},
6418 {"fnv1a_64", (test_callback_fn
)pre_hash_fnv1a_64
, 0, tests
},
6419 {"fnv1_32", (test_callback_fn
)pre_hash_fnv1_32
, 0, tests
},
6420 {"fnv1a_32", (test_callback_fn
)pre_hash_fnv1a_32
, 0, tests
},
6421 {"ketama", (test_callback_fn
)pre_behavior_ketama
, 0, tests
},
6422 {"ketama_auto_eject_hosts", (test_callback_fn
)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6423 {"unix_socket", (test_callback_fn
)pre_unix_socket
, 0, tests
},
6424 {"unix_socket_nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6425 {"poll_timeout", (test_callback_fn
)poll_timeout
, 0, tests
},
6426 {"gets", (test_callback_fn
)enable_cas
, 0, tests
},
6427 {"consistent_crc", (test_callback_fn
)enable_consistent_crc
, 0, tests
},
6428 {"consistent_hsieh", (test_callback_fn
)enable_consistent_hsieh
, 0, tests
},
6429 #ifdef MEMCACHED_ENABLE_DEPRECATED
6430 {"deprecated_memory_allocators", (test_callback_fn
)deprecated_set_memory_alloc
, 0, tests
},
6432 {"memory_allocators", (test_callback_fn
)set_memory_alloc
, 0, tests
},
6433 {"prefix", (test_callback_fn
)set_prefix
, 0, tests
},
6434 {"sasl_auth", (test_callback_fn
)pre_sasl
, 0, sasl_auth_tests
},
6435 {"sasl", (test_callback_fn
)pre_sasl
, 0, tests
},
6436 {"version_1_2_3", (test_callback_fn
)check_for_1_2_3
, 0, version_1_2_3
},
6437 {"string", 0, 0, string_tests
},
6438 {"result", 0, 0, result_tests
},
6439 {"async", (test_callback_fn
)pre_nonblock
, 0, async_tests
},
6440 {"async_binary", (test_callback_fn
)pre_nonblock_binary
, 0, async_tests
},
6441 {"user", 0, 0, user_tests
},
6442 {"generate", 0, 0, generate_tests
},
6443 {"generate_hsieh", (test_callback_fn
)pre_hsieh
, 0, generate_tests
},
6444 {"generate_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, generate_tests
},
6445 {"generate_hsieh_consistent", (test_callback_fn
)enable_consistent_hsieh
, 0, generate_tests
},
6446 {"generate_md5", (test_callback_fn
)pre_md5
, 0, generate_tests
},
6447 {"generate_murmur", (test_callback_fn
)pre_murmur
, 0, generate_tests
},
6448 {"generate_jenkins", (test_callback_fn
)pre_jenkins
, 0, generate_tests
},
6449 {"generate_nonblock", (test_callback_fn
)pre_nonblock
, 0, generate_tests
},
6451 {"generate_corked", (test_callback_fn
)pre_cork
, 0, generate_tests
},
6452 {"generate_corked_and_nonblock", (test_callback_fn
)pre_cork_and_nonblock
, 0, generate_tests
},
6453 {"consistent_not", 0, 0, consistent_tests
},
6454 {"consistent_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, consistent_tests
},
6455 {"consistent_ketama_weighted", (test_callback_fn
)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6456 {"ketama_compat", 0, 0, ketama_compatibility
},
6457 {"test_hashes", 0, 0, hash_tests
},
6458 {"replication", (test_callback_fn
)pre_replication
, 0, replication_tests
},
6459 {"replication_noblock", (test_callback_fn
)pre_replication_noblock
, 0, replication_tests
},
6460 {"regression", 0, 0, regression_tests
},
6461 {"behaviors", 0, 0, behavior_tests
},
6462 {"regression_binary_vs_block", (test_callback_fn
)key_setup
, (test_callback_fn
)key_teardown
, regression_binary_vs_block
},
6463 {"error_conditions", 0, 0, error_conditions
},
6467 #define SERVERS_TO_CREATE 5
6469 #include "libmemcached_world.h"
6471 void get_world(world_st
*world
)
6473 world
->collections
= collection
;
6475 world
->create
= (test_callback_create_fn
)world_create
;
6476 world
->destroy
= (test_callback_fn
)world_destroy
;
6478 world
->test
.startup
= (test_callback_fn
)world_test_startup
;
6479 world
->test
.flush
= (test_callback_fn
)world_flush
;
6480 world
->test
.pre_run
= (test_callback_fn
)world_pre_run
;
6481 world
->test
.post_run
= (test_callback_fn
)world_post_run
;
6482 world
->test
.on_error
= (test_callback_error_fn
)world_on_error
;
6484 world
->collection
.startup
= (test_callback_fn
)world_container_startup
;
6485 world
->collection
.shutdown
= (test_callback_fn
)world_container_shutdown
;
6487 world
->runner
= &defualt_libmemcached_runner
;