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 %d.%d.%d\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 sprintf(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%zu", 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 return ((rc
== MEMCACHED_END
) || (rc
== MEMCACHED_SUCCESS
)) ? TEST_SUCCESS
: TEST_FAILURE
;
2077 /* Test case provided by Cal Haldenbrand */
2078 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2080 unsigned int setter
= 1;
2082 unsigned long long total
= 0;
2085 char randomstuff
[6 * 1024];
2086 memcached_return_t rc
;
2088 memset(randomstuff
, 0, 6 * 1024);
2090 /* We just keep looking at the same values over and over */
2093 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2094 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2098 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2102 size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2103 memset(randomstuff
, 0, 6 * 1024);
2104 test_true(size
< 6 * 1024); /* Being safe here */
2106 for (j
= 0 ; j
< size
;j
++)
2107 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2110 snprintf(key
, sizeof(key
), "%u", x
);
2111 rc
= memcached_set(memc
, key
, strlen(key
),
2112 randomstuff
, strlen(randomstuff
), 10, 0);
2113 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2114 /* If we fail, lets try again */
2115 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
2116 rc
= memcached_set(memc
, key
, strlen(key
),
2117 randomstuff
, strlen(randomstuff
), 10, 0);
2118 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2121 return TEST_SUCCESS
;
2124 /* Test case provided by Cal Haldenbrand */
2125 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2127 unsigned int setter
;
2131 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2132 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2134 setter
= 20 * 1024576;
2135 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2136 setter
= 20 * 1024576;
2137 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2138 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2139 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2141 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2144 for (uint32_t x
= 0, errors
= 0; total
< 24576 ; x
++)
2146 memcached_return_t rc
= MEMCACHED_SUCCESS
;
2147 char buffer
[SMALL_STRING_LEN
];
2152 memset(buffer
, 0, SMALL_STRING_LEN
);
2154 snprintf(buffer
, sizeof(buffer
), "%u", x
);
2155 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
2156 &val_len
, &flags
, &rc
);
2157 if (rc
!= MEMCACHED_SUCCESS
)
2159 if (rc
== MEMCACHED_NOTFOUND
)
2173 return TEST_SUCCESS
;
2176 /* Do a large mget() over all the keys we think exist */
2177 #define KEY_COUNT 3000 // * 1024576
2178 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2180 memcached_return_t rc
;
2181 unsigned int setter
;
2184 size_t key_lengths
[KEY_COUNT
];
2187 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2188 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2190 setter
= 20 * 1024576;
2191 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2192 setter
= 20 * 1024576;
2193 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2194 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2195 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2198 keys
= calloc(KEY_COUNT
, sizeof(char *));
2200 for (x
= 0; x
< KEY_COUNT
; x
++)
2204 snprintf(buffer
, 30, "%u", x
);
2205 keys
[x
]= strdup(buffer
);
2206 key_lengths
[x
]= strlen(keys
[x
]);
2209 rc
= memcached_mget(memc
, (const char **)keys
, key_lengths
, KEY_COUNT
);
2210 test_true(rc
== MEMCACHED_SUCCESS
);
2212 test_true(fetch_all_results(memc
) == TEST_SUCCESS
);
2214 for (x
= 0; x
< KEY_COUNT
; x
++)
2218 return TEST_SUCCESS
;
2221 /* Make sure we behave properly if server list has no values */
2222 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2224 memcached_return_t rc
;
2225 const char *keys
[]= {"fudge", "son", "food"};
2226 size_t key_length
[]= {5, 3, 4};
2229 char return_key
[MEMCACHED_MAX_KEY
];
2230 size_t return_key_length
;
2232 size_t return_value_length
;
2234 /* Here we free everything before running a bunch of mget tests */
2235 memcached_servers_reset(memc
);
2238 /* We need to empty the server before continueing test */
2239 rc
= memcached_flush(memc
, 0);
2240 test_true(rc
== MEMCACHED_NO_SERVERS
);
2242 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2243 test_true(rc
== MEMCACHED_NO_SERVERS
);
2245 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2246 &return_value_length
, &flags
, &rc
)) != NULL
)
2248 test_true(return_value
);
2250 test_true(!return_value
);
2251 test_true(return_value_length
== 0);
2252 test_true(rc
== MEMCACHED_NO_SERVERS
);
2254 for (x
= 0; x
< 3; x
++)
2256 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2257 keys
[x
], key_length
[x
],
2258 (time_t)50, (uint32_t)9);
2259 test_true(rc
== MEMCACHED_NO_SERVERS
);
2262 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2263 test_true(rc
== MEMCACHED_NO_SERVERS
);
2266 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2267 &return_value_length
, &flags
, &rc
)))
2269 test_true(return_value
);
2270 test_true(rc
== MEMCACHED_SUCCESS
);
2271 test_true(return_key_length
== return_value_length
);
2272 test_true(!memcmp(return_value
, return_key
, return_value_length
));
2277 return TEST_SUCCESS
;
2280 #define VALUE_SIZE_BUG5 1048064
2281 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2283 memcached_return_t rc
;
2284 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2285 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2286 char return_key
[MEMCACHED_MAX_KEY
];
2287 size_t return_key_length
;
2289 size_t value_length
;
2293 char insert_data
[VALUE_SIZE_BUG5
];
2295 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2296 insert_data
[x
]= (signed char)rand();
2298 memcached_flush(memc
, 0);
2299 value
= memcached_get(memc
, keys
[0], key_length
[0],
2300 &value_length
, &flags
, &rc
);
2301 test_true(value
== NULL
);
2302 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2305 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2306 &value_length
, &flags
, &rc
)))
2308 test_true(count
== 0);
2310 for (x
= 0; x
< 4; x
++)
2312 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2313 insert_data
, VALUE_SIZE_BUG5
,
2314 (time_t)0, (uint32_t)0);
2315 test_true(rc
== MEMCACHED_SUCCESS
);
2318 for (x
= 0; x
< 10; x
++)
2320 value
= memcached_get(memc
, keys
[0], key_length
[0],
2321 &value_length
, &flags
, &rc
);
2325 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2327 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2328 &value_length
, &flags
, &rc
)))
2333 test_true(count
== 4);
2336 return TEST_SUCCESS
;
2339 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2341 memcached_return_t rc
;
2342 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2343 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2344 char return_key
[MEMCACHED_MAX_KEY
];
2345 size_t return_key_length
;
2347 size_t value_length
;
2351 char insert_data
[VALUE_SIZE_BUG5
];
2353 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2354 insert_data
[x
]= (signed char)rand();
2356 memcached_flush(memc
, 0);
2357 value
= memcached_get(memc
, keys
[0], key_length
[0],
2358 &value_length
, &flags
, &rc
);
2359 test_true(value
== NULL
);
2360 test_true(rc
== MEMCACHED_NOTFOUND
);
2361 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2362 test_true(rc
== MEMCACHED_SUCCESS
);
2365 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2366 &value_length
, &flags
, &rc
)))
2368 test_true(count
== 0);
2369 test_true(rc
== MEMCACHED_END
);
2371 for (x
= 0; x
< 4; x
++)
2373 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2374 insert_data
, VALUE_SIZE_BUG5
,
2375 (time_t)0, (uint32_t)0);
2376 test_true(rc
== MEMCACHED_SUCCESS
);
2379 for (x
= 0; x
< 2; x
++)
2381 value
= memcached_get(memc
, keys
[0], key_length
[0],
2382 &value_length
, &flags
, &rc
);
2386 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2387 test_true(rc
== MEMCACHED_SUCCESS
);
2389 /* We test for purge of partial complete fetches */
2390 for (count
= 3; count
; count
--)
2392 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2393 &value_length
, &flags
, &rc
);
2394 test_true(rc
== MEMCACHED_SUCCESS
);
2395 test_true(!(memcmp(value
, insert_data
, value_length
)));
2396 test_true(value_length
);
2401 return TEST_SUCCESS
;
2404 static test_return_t
user_supplied_bug8(memcached_st
*memc
__attribute__((unused
)))
2406 memcached_return_t rc
;
2408 memcached_st
*memc_clone
;
2410 memcached_server_st
*servers
;
2411 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";
2413 servers
= memcached_servers_parse(server_list
);
2416 mine
= memcached_create(NULL
);
2417 rc
= memcached_server_push(mine
, servers
);
2418 test_true(rc
== MEMCACHED_SUCCESS
);
2419 memcached_server_list_free(servers
);
2422 memc_clone
= memcached_clone(NULL
, mine
);
2424 memcached_quit(mine
);
2425 memcached_quit(memc_clone
);
2428 memcached_free(mine
);
2429 memcached_free(memc_clone
);
2431 return TEST_SUCCESS
;
2434 /* Test flag store/retrieve */
2435 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2437 memcached_return_t rc
;
2438 const char *keys
= "036790384900";
2439 size_t key_length
= strlen(keys
);
2440 char return_key
[MEMCACHED_MAX_KEY
];
2441 size_t return_key_length
;
2443 size_t value_length
;
2446 char insert_data
[VALUE_SIZE_BUG5
];
2448 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2449 insert_data
[x
]= (signed char)rand();
2451 memcached_flush(memc
, 0);
2454 rc
= memcached_set(memc
, keys
, key_length
,
2455 insert_data
, VALUE_SIZE_BUG5
,
2457 test_true(rc
== MEMCACHED_SUCCESS
);
2460 value
= memcached_get(memc
, keys
, key_length
,
2461 &value_length
, &flags
, &rc
);
2462 test_true(flags
== 245);
2466 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2469 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2470 &value_length
, &flags
, &rc
);
2471 test_true(flags
== 245);
2476 return TEST_SUCCESS
;
2479 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2481 memcached_return_t rc
;
2482 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2483 size_t key_length
[3];
2488 char return_key
[MEMCACHED_MAX_KEY
];
2489 size_t return_key_length
;
2491 size_t return_value_length
;
2494 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2495 key_length
[1]= strlen("fudge&*@#");
2496 key_length
[2]= strlen("for^#@&$not");
2499 for (x
= 0; x
< 3; x
++)
2501 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2502 keys
[x
], key_length
[x
],
2503 (time_t)50, (uint32_t)9);
2504 test_true(rc
== MEMCACHED_SUCCESS
);
2507 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2508 test_true(rc
== MEMCACHED_SUCCESS
);
2510 /* We need to empty the server before continueing test */
2511 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2512 &return_value_length
, &flags
, &rc
)) != NULL
)
2514 test_true(return_value
);
2518 test_true(count
== 3);
2520 return TEST_SUCCESS
;
2523 /* We are testing with aggressive timeout to get failures */
2524 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2526 const char *key
= "foo";
2528 size_t value_length
= 512;
2531 memcached_return_t rc
;
2532 unsigned int set
= 1;
2533 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2536 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2537 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2539 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2542 value
= (char*)malloc(value_length
* sizeof(char));
2544 for (x
= 0; x
< value_length
; x
++)
2545 value
[x
]= (char) (x
% 127);
2547 for (x
= 1; x
<= 100000; ++x
)
2549 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2551 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2552 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2554 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2559 memcached_free(mclone
);
2561 return TEST_SUCCESS
;
2565 We are looking failures in the async protocol
2567 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2569 const char *key
= "foo";
2571 size_t value_length
= 512;
2574 memcached_return_t rc
;
2575 unsigned int set
= 1;
2577 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2579 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2580 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2582 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2585 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2587 test_true(timeout
== -1);
2589 value
= (char*)malloc(value_length
* sizeof(char));
2591 for (x
= 0; x
< value_length
; x
++)
2592 value
[x
]= (char) (x
% 127);
2594 for (x
= 1; x
<= 100000; ++x
)
2596 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2600 memcached_free(mclone
);
2602 return TEST_SUCCESS
;
2606 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2608 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2610 memcached_return_t rc
;
2612 size_t value_length
;
2614 uint64_t number_value
;
2616 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2617 &value_length
, &flags
, &rc
);
2618 test_true(value
== NULL
);
2619 test_true(rc
== MEMCACHED_NOTFOUND
);
2621 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2624 test_true(value
== NULL
);
2625 /* The binary protocol will set the key if it doesn't exist */
2626 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2628 test_true(rc
== MEMCACHED_SUCCESS
);
2632 test_true(rc
== MEMCACHED_NOTFOUND
);
2635 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2637 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2638 &value_length
, &flags
, &rc
);
2640 test_true(rc
== MEMCACHED_SUCCESS
);
2643 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2645 test_true(number_value
== 2);
2646 test_true(rc
== MEMCACHED_SUCCESS
);
2648 return TEST_SUCCESS
;
2652 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2653 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2655 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2657 char key
[] = "key34567890";
2659 memcached_return_t rc
;
2660 size_t overflowSize
;
2662 char commandFirst
[]= "set key34567890 0 0 ";
2663 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2664 size_t commandLength
;
2667 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2669 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2671 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2673 overflow
= malloc(testSize
);
2674 test_true(overflow
!= NULL
);
2676 memset(overflow
, 'x', testSize
);
2677 rc
= memcached_set(memc
, key
, strlen(key
),
2678 overflow
, testSize
, 0, 0);
2679 test_true(rc
== MEMCACHED_SUCCESS
);
2683 return TEST_SUCCESS
;
2688 Test values of many different sizes
2689 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2690 set key34567890 0 0 8169 \r\n
2691 is sent followed by buffer of size 8169, followed by 8169
2693 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2696 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2697 memcached_return_t rc
;
2698 const char *key
= "foo";
2700 size_t value_length
= 18000;
2702 size_t string_length
;
2705 size_t current_length
;
2707 value
= (char*)malloc(value_length
);
2710 for (x
= 0; x
< value_length
; x
++)
2711 value
[x
] = (char) (x
% 127);
2713 for (current_length
= 0; current_length
< value_length
; current_length
++)
2715 rc
= memcached_set(memc
, key
, strlen(key
),
2716 value
, current_length
,
2717 (time_t)0, (uint32_t)0);
2718 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2720 string
= memcached_get(memc
, key
, strlen(key
),
2721 &string_length
, &flags
, &rc
);
2723 test_true(rc
== MEMCACHED_SUCCESS
);
2724 test_true(string_length
== current_length
);
2725 test_true(!memcmp(string
, value
, string_length
));
2732 return TEST_SUCCESS
;
2736 Look for zero length value problems
2738 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2741 memcached_return_t rc
;
2742 const char *key
= "mykey";
2747 for (x
= 0; x
< 2; x
++)
2749 rc
= memcached_set(memc
, key
, strlen(key
),
2751 (time_t)0, (uint32_t)0);
2753 test_true(rc
== MEMCACHED_SUCCESS
);
2755 value
= memcached_get(memc
, key
, strlen(key
),
2756 &length
, &flags
, &rc
);
2758 test_true(rc
== MEMCACHED_SUCCESS
);
2759 test_true(value
== NULL
);
2760 test_true(length
== 0);
2761 test_true(flags
== 0);
2763 value
= memcached_get(memc
, key
, strlen(key
),
2764 &length
, &flags
, &rc
);
2766 test_true(rc
== MEMCACHED_SUCCESS
);
2767 test_true(value
== NULL
);
2768 test_true(length
== 0);
2769 test_true(flags
== 0);
2772 return TEST_SUCCESS
;
2775 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2776 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2778 memcached_return_t rc
;
2779 const char *key
= "mykey";
2784 rc
= memcached_set(memc
, key
, strlen(key
),
2786 (time_t)0, UINT32_MAX
);
2788 test_true(rc
== MEMCACHED_SUCCESS
);
2790 value
= memcached_get(memc
, key
, strlen(key
),
2791 &length
, &flags
, &rc
);
2793 test_true(rc
== MEMCACHED_SUCCESS
);
2794 test_true(value
== NULL
);
2795 test_true(length
== 0);
2796 test_true(flags
== UINT32_MAX
);
2798 return TEST_SUCCESS
;
2801 #if !defined(__sun) && !defined(__OpenBSD__)
2802 /* Check the validity of chinese key*/
2803 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2805 memcached_return_t rc
;
2806 const char *key
= "豆瓣";
2807 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2812 rc
= memcached_set(memc
, key
, strlen(key
),
2813 value
, strlen(value
),
2816 test_true(rc
== MEMCACHED_SUCCESS
);
2818 value2
= memcached_get(memc
, key
, strlen(key
),
2819 &length
, &flags
, &rc
);
2821 test_true(length
==strlen(value
));
2822 test_true(rc
== MEMCACHED_SUCCESS
);
2823 test_true(memcmp(value
, value2
, length
)==0);
2826 return TEST_SUCCESS
;
2834 static test_return_t
user_supplied_bug19(memcached_st
*not_used
)
2837 const memcached_server_st
*server
;
2838 memcached_return_t res
;
2842 memc
= memcached_create(NULL
);
2843 memcached_server_add_with_weight(memc
, "localhost", 11311, 100);
2844 memcached_server_add_with_weight(memc
, "localhost", 11312, 100);
2846 server
= memcached_server_by_key(memc
, "a", 1, &res
);
2848 memcached_free(memc
);
2850 return TEST_SUCCESS
;
2853 /* CAS test from Andei */
2854 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2856 memcached_return_t status
;
2857 memcached_result_st
*result
, result_obj
;
2858 const char *key
= "abc";
2859 size_t key_len
= strlen("abc");
2860 const char *value
= "foobar";
2861 size_t value_len
= strlen(value
);
2863 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2865 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2866 test_true(status
== MEMCACHED_SUCCESS
);
2868 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2869 test_true(status
== MEMCACHED_SUCCESS
);
2871 result
= memcached_result_create(memc
, &result_obj
);
2874 memcached_result_create(memc
, &result_obj
);
2875 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2878 test_true(status
== MEMCACHED_SUCCESS
);
2880 memcached_result_free(result
);
2882 return TEST_SUCCESS
;
2885 #include "ketama_test_cases.h"
2886 static test_return_t
user_supplied_bug18(memcached_st
*trash
)
2888 memcached_return_t rc
;
2891 memcached_server_st
*server_pool
;
2896 memc
= memcached_create(NULL
);
2899 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2900 test_true(rc
== MEMCACHED_SUCCESS
);
2902 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2903 test_true(value
== 1);
2905 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2906 test_true(rc
== MEMCACHED_SUCCESS
);
2908 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2909 test_true(value
== MEMCACHED_HASH_MD5
);
2911 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");
2912 memcached_server_push(memc
, server_pool
);
2914 /* verify that the server list was parsed okay. */
2915 test_true(memcached_server_count(memc
) == 8);
2916 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2917 test_true(server_pool
[0].port
== 11211);
2918 test_true(server_pool
[0].weight
== 600);
2919 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2920 test_true(server_pool
[2].port
== 11211);
2921 test_true(server_pool
[2].weight
== 200);
2922 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2923 test_true(server_pool
[7].port
== 11211);
2924 test_true(server_pool
[7].weight
== 100);
2926 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2927 * us test the boundary wraparound.
2929 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
2931 /* verify the standard ketama set. */
2932 for (x
= 0; x
< 99; x
++)
2934 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2936 memcached_server_instance_st instance
=
2937 memcached_server_instance_by_position(memc
, server_idx
);
2939 const char *hostname
= memcached_server_name(instance
);
2940 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
2943 memcached_server_list_free(server_pool
);
2944 memcached_free(memc
);
2946 return TEST_SUCCESS
;
2949 /* Large mget() of missing keys with binary proto
2951 * If many binary quiet commands (such as getq's in an mget) fill the output
2952 * buffer and the server chooses not to respond, memcached_flush hangs. See
2953 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2956 /* sighandler_t function that always asserts false */
2957 static void fail(int unused
__attribute__((unused
)))
2963 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2968 return TEST_SKIPPED
;
2970 memcached_return_t rc
;
2973 size_t* key_lengths
;
2974 void (*oldalarm
)(int);
2975 memcached_st
*memc_clone
;
2977 memc_clone
= memcached_clone(NULL
, memc
);
2978 test_true(memc_clone
);
2980 /* only binproto uses getq for mget */
2981 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2983 /* empty the cache to ensure misses (hence non-responses) */
2984 rc
= memcached_flush(memc_clone
, 0);
2985 test_true(rc
== MEMCACHED_SUCCESS
);
2987 key_lengths
= calloc(key_count
, sizeof(size_t));
2988 keys
= calloc(key_count
, sizeof(char *));
2990 for (x
= 0; x
< key_count
; x
++)
2994 snprintf(buffer
, 30, "%u", x
);
2995 keys
[x
]= strdup(buffer
);
2996 key_lengths
[x
]= strlen(keys
[x
]);
2999 oldalarm
= signal(SIGALRM
, fail
);
3002 rc
= memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
);
3003 test_true(rc
== MEMCACHED_SUCCESS
);
3006 signal(SIGALRM
, oldalarm
);
3008 test_true(fetch_all_results(memc
) == TEST_SUCCESS
);
3010 for (x
= 0; x
< key_count
; x
++)
3015 memcached_free(memc_clone
);
3017 return TEST_SUCCESS
;
3021 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3023 test_return_t test_rc
;
3024 test_rc
= pre_binary(memc
);
3026 if (test_rc
!= TEST_SUCCESS
)
3031 /* should work as of r580 */
3032 rc
= _user_supplied_bug21(memc
, 10);
3033 test_true(rc
== TEST_SUCCESS
);
3035 /* should fail as of r580 */
3036 rc
= _user_supplied_bug21(memc
, 1000);
3037 test_true(rc
== TEST_SUCCESS
);
3039 return TEST_SUCCESS
;
3042 static test_return_t
auto_eject_hosts(memcached_st
*trash
)
3045 memcached_server_instance_st instance
;
3047 memcached_return_t rc
;
3048 memcached_st
*memc
= memcached_create(NULL
);
3051 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3052 test_true(rc
== MEMCACHED_SUCCESS
);
3054 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3055 test_true(value
== 1);
3057 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3058 test_true(rc
== MEMCACHED_SUCCESS
);
3060 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3061 test_true(value
== MEMCACHED_HASH_MD5
);
3063 /* server should be removed when in delay */
3064 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
3065 test_true(rc
== MEMCACHED_SUCCESS
);
3067 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
3068 test_true(value
== 1);
3070 memcached_server_st
*server_pool
;
3071 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");
3072 memcached_server_push(memc
, server_pool
);
3074 /* verify that the server list was parsed okay. */
3075 test_true(memcached_server_count(memc
) == 8);
3076 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
3077 test_true(server_pool
[0].port
== 11211);
3078 test_true(server_pool
[0].weight
== 600);
3079 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
3080 test_true(server_pool
[2].port
== 11211);
3081 test_true(server_pool
[2].weight
== 200);
3082 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
3083 test_true(server_pool
[7].port
== 11211);
3084 test_true(server_pool
[7].weight
== 100);
3086 instance
= memcached_server_instance_by_position(memc
, 2);
3087 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) + 15;
3088 memc
->next_distribution_rebuild
= time(NULL
) - 1;
3091 This would not work if there were only two hosts.
3093 for (size_t x
= 0; x
< 99; x
++)
3095 memcached_autoeject(memc
);
3096 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3097 test_true(server_idx
!= 2);
3100 /* and re-added when it's back. */
3101 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) - 1;
3102 memc
->next_distribution_rebuild
= time(NULL
) - 1;
3103 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
,
3104 memc
->distribution
);
3105 for (size_t x
= 0; x
< 99; x
++)
3107 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3108 // We re-use instance from above.
3110 memcached_server_instance_by_position(memc
, server_idx
);
3111 const char *hostname
= memcached_server_name(instance
);
3112 test_true(strcmp(hostname
, ketama_test_cases
[x
].server
) == 0);
3115 memcached_server_list_free(server_pool
);
3116 memcached_free(memc
);
3118 return TEST_SUCCESS
;
3121 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
3125 memcached_return_t rc
;
3126 memcached_st
*memc
= memcached_create(NULL
);
3130 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3131 test_true(rc
== MEMCACHED_SUCCESS
);
3133 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3134 test_true(value
== 1);
3136 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3137 test_true(rc
== MEMCACHED_SUCCESS
);
3139 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3140 test_true(value
== MEMCACHED_HASH_MD5
);
3143 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3145 memcached_server_st
*server_pool
;
3146 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");
3147 memcached_server_push(memc
, server_pool
);
3149 // @todo this needs to be refactored to actually test something.
3152 if ((fp
= fopen("ketama_keys.txt", "w")))
3156 printf("cannot write to file ketama_keys.txt");
3157 return TEST_FAILURE
;
3160 for (int x
= 0; x
< 10000; x
++)
3163 sprintf(key
, "%d", x
);
3165 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3166 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3167 in_port_t port
= memc
->hosts
[server_idx
].port
;
3168 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3169 memcached_server_instance_st instance
=
3170 memcached_server_instance_by_position(memc
, host_index
);
3174 memcached_server_list_free(server_pool
);
3175 memcached_free(memc
);
3177 return TEST_SUCCESS
;
3181 static test_return_t
result_static(memcached_st
*memc
)
3183 memcached_result_st result
;
3184 memcached_result_st
*result_ptr
;
3186 result_ptr
= memcached_result_create(memc
, &result
);
3187 test_true(result
.options
.is_allocated
== false);
3188 test_true(memcached_is_initialized(&result
) == true);
3189 test_true(result_ptr
);
3190 test_true(result_ptr
== &result
);
3192 memcached_result_free(&result
);
3194 test_true(result
.options
.is_allocated
== false);
3195 test_true(memcached_is_initialized(&result
) == false);
3197 return TEST_SUCCESS
;
3200 static test_return_t
result_alloc(memcached_st
*memc
)
3202 memcached_result_st
*result_ptr
;
3204 result_ptr
= memcached_result_create(memc
, NULL
);
3205 test_true(result_ptr
);
3206 test_true(result_ptr
->options
.is_allocated
== true);
3207 test_true(memcached_is_initialized(result_ptr
) == true);
3208 memcached_result_free(result_ptr
);
3210 return TEST_SUCCESS
;
3213 static test_return_t
string_static_null(memcached_st
*memc
)
3215 memcached_string_st string
;
3216 memcached_string_st
*string_ptr
;
3218 string_ptr
= memcached_string_create(memc
, &string
, 0);
3219 test_true(string
.options
.is_initialized
== true);
3220 test_true(string_ptr
);
3222 /* The following two better be the same! */
3223 test_true(memcached_is_allocated(string_ptr
) == false);
3224 test_true(memcached_is_allocated(&string
) == false);
3225 test_true(&string
== string_ptr
);
3227 test_true(string
.options
.is_initialized
== true);
3228 test_true(memcached_is_initialized(&string
) == true);
3229 memcached_string_free(&string
);
3230 test_true(memcached_is_initialized(&string
) == false);
3232 return TEST_SUCCESS
;
3235 static test_return_t
string_alloc_null(memcached_st
*memc
)
3237 memcached_string_st
*string
;
3239 string
= memcached_string_create(memc
, NULL
, 0);
3241 test_true(memcached_is_allocated(string
) == true);
3242 test_true(memcached_is_initialized(string
) == true);
3243 memcached_string_free(string
);
3245 return TEST_SUCCESS
;
3248 static test_return_t
string_alloc_with_size(memcached_st
*memc
)
3250 memcached_string_st
*string
;
3252 string
= memcached_string_create(memc
, NULL
, 1024);
3254 test_true(memcached_is_allocated(string
) == true);
3255 test_true(memcached_is_initialized(string
) == true);
3256 memcached_string_free(string
);
3258 return TEST_SUCCESS
;
3261 static test_return_t
string_alloc_with_size_toobig(memcached_st
*memc
)
3263 memcached_string_st
*string
;
3265 string
= memcached_string_create(memc
, NULL
, SIZE_MAX
);
3266 test_true(string
== NULL
);
3268 return TEST_SUCCESS
;
3271 static test_return_t
string_alloc_append(memcached_st
*memc
)
3274 char buffer
[SMALL_STRING_LEN
];
3275 memcached_string_st
*string
;
3277 /* Ring the bell! */
3278 memset(buffer
, 6, SMALL_STRING_LEN
);
3280 string
= memcached_string_create(memc
, NULL
, 100);
3282 test_true(memcached_is_allocated(string
) == true);
3283 test_true(memcached_is_initialized(string
) == true);
3285 for (x
= 0; x
< 1024; x
++)
3287 memcached_return_t rc
;
3288 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
3289 test_true(rc
== MEMCACHED_SUCCESS
);
3291 test_true(memcached_is_allocated(string
) == true);
3292 memcached_string_free(string
);
3294 return TEST_SUCCESS
;
3297 static test_return_t
string_alloc_append_toobig(memcached_st
*memc
)
3299 memcached_return_t rc
;
3301 char buffer
[SMALL_STRING_LEN
];
3302 memcached_string_st
*string
;
3304 /* Ring the bell! */
3305 memset(buffer
, 6, SMALL_STRING_LEN
);
3307 string
= memcached_string_create(memc
, NULL
, 100);
3309 test_true(memcached_is_allocated(string
) == true);
3310 test_true(memcached_is_initialized(string
) == true);
3312 for (x
= 0; x
< 1024; x
++)
3314 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
3315 test_true(rc
== MEMCACHED_SUCCESS
);
3317 rc
= memcached_string_append(string
, buffer
, SIZE_MAX
);
3318 test_true(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
3319 test_true(memcached_is_allocated(string
) == true);
3320 memcached_string_free(string
);
3322 return TEST_SUCCESS
;
3325 static test_return_t
cleanup_pairs(memcached_st
*memc
__attribute__((unused
)))
3327 pairs_free(global_pairs
);
3329 return TEST_SUCCESS
;
3332 static test_return_t
generate_pairs(memcached_st
*memc
__attribute__((unused
)))
3334 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3335 global_count
= GLOBAL_COUNT
;
3337 for (size_t x
= 0; x
< global_count
; x
++)
3339 global_keys
[x
]= global_pairs
[x
].key
;
3340 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3343 return TEST_SUCCESS
;
3346 static test_return_t
generate_large_pairs(memcached_st
*memc
__attribute__((unused
)))
3348 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3349 global_count
= GLOBAL2_COUNT
;
3351 for (size_t x
= 0; x
< global_count
; x
++)
3353 global_keys
[x
]= global_pairs
[x
].key
;
3354 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3357 return TEST_SUCCESS
;
3360 static test_return_t
generate_data(memcached_st
*memc
)
3362 execute_set(memc
, global_pairs
, global_count
);
3364 return TEST_SUCCESS
;
3367 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3369 memcached_stat_st
*stat_p
;
3370 memcached_return_t rc
;
3371 uint32_t host_index
= 0;
3372 execute_set(memc
, global_pairs
, global_count
);
3374 //TODO: hosts used size stats
3375 stat_p
= memcached_stat(memc
, NULL
, &rc
);
3378 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3380 /* This test was changes so that "make test" would work properlly */
3382 memcached_server_instance_st instance
=
3383 memcached_server_instance_by_position(memc
, host_index
);
3385 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3387 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3390 memcached_stat_free(NULL
, stat_p
);
3392 return TEST_SUCCESS
;
3394 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3399 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3400 generate_data(memc
);
3402 return TEST_SUCCESS
;
3405 static test_return_t
get_read_count(memcached_st
*memc
)
3407 memcached_return_t rc
;
3408 memcached_st
*memc_clone
;
3410 memc_clone
= memcached_clone(NULL
, memc
);
3411 test_true(memc_clone
);
3413 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3417 size_t return_value_length
;
3421 for (size_t x
= count
= 0; x
< global_count
; x
++)
3423 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3424 &return_value_length
, &flags
, &rc
);
3425 if (rc
== MEMCACHED_SUCCESS
)
3434 memcached_free(memc_clone
);
3436 return TEST_SUCCESS
;
3439 static test_return_t
get_read(memcached_st
*memc
)
3441 memcached_return_t rc
;
3445 size_t return_value_length
;
3448 for (size_t x
= 0; x
< global_count
; x
++)
3450 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3451 &return_value_length
, &flags
, &rc
);
3453 test_true(return_value);
3454 test_true(rc == MEMCACHED_SUCCESS);
3456 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3461 return TEST_SUCCESS
;
3464 static test_return_t
mget_read(memcached_st
*memc
)
3466 memcached_return_t rc
;
3468 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3469 test_true(rc
== MEMCACHED_SUCCESS
);
3470 test_true(fetch_all_results(memc
) == TEST_SUCCESS
);
3472 return TEST_SUCCESS
;
3475 static test_return_t
mget_read_result(memcached_st
*memc
)
3477 memcached_return_t rc
;
3479 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3480 test_true(rc
== MEMCACHED_SUCCESS
);
3481 /* Turn this into a help function */
3483 memcached_result_st results_obj
;
3484 memcached_result_st
*results
;
3486 results
= memcached_result_create(memc
, &results_obj
);
3488 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3491 test_true(rc
== MEMCACHED_SUCCESS
);
3494 memcached_result_free(&results_obj
);
3497 return TEST_SUCCESS
;
3500 static test_return_t
mget_read_function(memcached_st
*memc
)
3502 memcached_return_t rc
;
3504 memcached_execute_fn callbacks
[1];
3506 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3507 test_true(rc
== MEMCACHED_SUCCESS
);
3509 callbacks
[0]= &callback_counter
;
3511 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
3513 return TEST_SUCCESS
;
3516 static test_return_t
delete_generate(memcached_st
*memc
)
3518 for (size_t x
= 0; x
< global_count
; x
++)
3520 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3523 return TEST_SUCCESS
;
3526 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3531 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3533 for (size_t x
= 0; x
< global_count
; x
++)
3535 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3538 return TEST_SUCCESS
;
3541 static test_return_t
add_host_test1(memcached_st
*memc
)
3543 memcached_return_t rc
;
3544 char servername
[]= "0.example.com";
3545 memcached_server_st
*servers
;
3547 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3549 test_true(1 == memcached_server_list_count(servers
));
3551 for (size_t x
= 2; x
< 20; x
++)
3553 char buffer
[SMALL_STRING_LEN
];
3555 snprintf(buffer
, SMALL_STRING_LEN
, "%zu.example.com", 400+x
);
3556 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3558 test_true(rc
== MEMCACHED_SUCCESS
);
3559 test_true(x
== memcached_server_list_count(servers
));
3562 rc
= memcached_server_push(memc
, servers
);
3563 test_true(rc
== MEMCACHED_SUCCESS
);
3564 rc
= memcached_server_push(memc
, servers
);
3565 test_true(rc
== MEMCACHED_SUCCESS
);
3567 memcached_server_list_free(servers
);
3569 return TEST_SUCCESS
;
3572 static test_return_t
pre_nonblock(memcached_st
*memc
)
3574 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3576 return TEST_SUCCESS
;
3579 static test_return_t
pre_cork(memcached_st
*memc
)
3581 memcached_return_t rc
;
3584 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
3587 return TEST_SKIPPED
;
3590 if (rc
== MEMCACHED_SUCCESS
)
3591 return TEST_SUCCESS
;
3593 return TEST_SKIPPED
;
3596 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3603 return TEST_SKIPPED
;
3606 if (rc
!= TEST_SUCCESS
)
3609 return pre_nonblock(memc
);
3612 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3614 memcached_return_t rc
= MEMCACHED_FAILURE
;
3615 memcached_st
*memc_clone
;
3617 memc_clone
= memcached_clone(NULL
, memc
);
3618 test_true(memc_clone
);
3619 // The memcached_version needs to be done on a clone, because the server
3620 // will not toggle protocol on an connection.
3621 memcached_version(memc_clone
);
3623 if (libmemcached_util_version_check(memc_clone
, 1, 3, 0))
3625 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3626 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3627 test_true(rc
== MEMCACHED_SUCCESS
);
3628 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3632 return TEST_SKIPPED
;
3635 memcached_free(memc_clone
);
3637 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3640 static test_return_t
pre_murmur(memcached_st
*memc
)
3642 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3644 return TEST_SUCCESS
;
3647 static test_return_t
pre_jenkins(memcached_st
*memc
)
3649 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3651 return TEST_SUCCESS
;
3655 static test_return_t
pre_md5(memcached_st
*memc
)
3657 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3659 return TEST_SUCCESS
;
3662 static test_return_t
pre_crc(memcached_st
*memc
)
3664 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3666 return TEST_SUCCESS
;
3669 static test_return_t
pre_hsieh(memcached_st
*memc
)
3671 #ifdef HAVE_HSIEH_HASH
3672 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3673 return TEST_SUCCESS
;
3676 return TEST_SKIPPED
;
3680 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3682 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3684 return TEST_SUCCESS
;
3687 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3689 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3691 return TEST_SUCCESS
;
3694 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3696 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3698 return TEST_SUCCESS
;
3701 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3703 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3705 return TEST_SUCCESS
;
3708 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3710 memcached_return_t rc
;
3713 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3714 test_true(rc
== MEMCACHED_SUCCESS
);
3716 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3717 test_true(value
== 1);
3719 return TEST_SUCCESS
;
3722 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3724 memcached_return_t rc
;
3727 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3728 test_true(rc
== MEMCACHED_SUCCESS
);
3730 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3731 test_true(value
== 1);
3733 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3734 test_true(rc
== MEMCACHED_SUCCESS
);
3736 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3737 test_true(value
== MEMCACHED_HASH_MD5
);
3739 return TEST_SUCCESS
;
3743 @note This should be testing to see if the server really supports the binary protocol.
3745 static test_return_t
pre_binary(memcached_st
*memc
)
3747 memcached_return_t rc
= MEMCACHED_FAILURE
;
3749 if (libmemcached_util_version_check(memc
, 1, 3, 0))
3751 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3752 test_true(rc
== MEMCACHED_SUCCESS
);
3753 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3756 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3759 static test_return_t
pre_sasl(memcached_st
*memc
)
3761 memcached_return_t rc
= MEMCACHED_FAILURE
;
3763 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
3764 const char *server
= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
3765 const char *user
= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
3766 const char *pass
= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
3768 if (server
!= NULL
&& user
!= NULL
&& pass
!= NULL
)
3770 memcached_server_st
*servers
= memcached_servers_parse(server
);
3771 test_true(servers
!= NULL
);
3772 memcached_servers_reset(memc
);
3773 test_true(memcached_server_push(memc
, servers
) == MEMCACHED_SUCCESS
);
3774 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3775 rc
= memcached_set_sasl_auth_data(memc
, user
, pass
);
3776 test_true(rc
== MEMCACHED_SUCCESS
);
3782 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3785 static test_return_t
pre_replication(memcached_st
*memc
)
3787 test_return_t test_rc
;
3788 test_rc
= pre_binary(memc
);
3790 if (test_rc
!= TEST_SUCCESS
)
3794 * Make sure that we store the item on all servers
3795 * (master + replicas == number of servers)
3797 memcached_return_t rc
;
3798 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3799 memcached_server_count(memc
) - 1);
3800 test_true(rc
== MEMCACHED_SUCCESS
);
3801 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memcached_server_count(memc
) - 1);
3803 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3807 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3811 rc
= pre_replication(memc
);
3812 if (rc
!= TEST_SUCCESS
)
3815 rc
= pre_nonblock(memc
);
3821 static void my_free(const memcached_st
*ptr
__attribute__((unused
)), void *mem
, void *context
)
3824 #ifdef HARD_MALLOC_TESTS
3825 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3833 static void *my_malloc(const memcached_st
*ptr
__attribute__((unused
)), const size_t size
, void *context
)
3836 #ifdef HARD_MALLOC_TESTS
3837 void *ret
= malloc(size
+ 8);
3840 ret
= (void*)((caddr_t
)ret
+ 8);
3843 void *ret
= malloc(size
);
3848 memset(ret
, 0xff, size
);
3855 static void *my_realloc(const memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
, void *context
)
3858 #ifdef HARD_MALLOC_TESTS
3859 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3860 void *nmem
= realloc(real_ptr
, size
+ 8);
3865 ret
= (void*)((caddr_t
)nmem
+ 8);
3870 return realloc(mem
, size
);
3875 static void *my_calloc(const memcached_st
*ptr
__attribute__((unused
)), size_t nelem
, const size_t size
, void *context
)
3878 #ifdef HARD_MALLOC_TESTS
3879 void *mem
= my_malloc(ptr
, nelem
* size
);
3882 memset(mem
, 0, nelem
* size
);
3887 return calloc(nelem
, size
);
3892 static test_return_t
set_prefix(memcached_st
*memc
)
3894 memcached_return_t rc
;
3895 const char *key
= "mine";
3898 /* Make sure be default none exists */
3899 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3900 test_true(rc
== MEMCACHED_FAILURE
);
3902 /* Test a clean set */
3903 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3904 test_true(rc
== MEMCACHED_SUCCESS
);
3906 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3907 test_true(memcmp(value
, key
, 4) == 0);
3908 test_true(rc
== MEMCACHED_SUCCESS
);
3910 /* Test that we can turn it off */
3911 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3912 test_true(rc
== MEMCACHED_SUCCESS
);
3914 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3915 test_true(rc
== MEMCACHED_FAILURE
);
3917 /* Now setup for main test */
3918 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3919 test_true(rc
== MEMCACHED_SUCCESS
);
3921 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3922 test_true(rc
== MEMCACHED_SUCCESS
);
3923 test_true(memcmp(value
, key
, 4) == 0);
3925 /* Set to Zero, and then Set to something too large */
3928 memset(long_key
, 0, 255);
3930 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3931 test_true(rc
== MEMCACHED_SUCCESS
);
3933 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3934 test_true(rc
== MEMCACHED_FAILURE
);
3935 test_true(value
== NULL
);
3937 /* Test a long key for failure */
3938 /* TODO, extend test to determine based on setting, what result should be */
3939 strcpy(long_key
, "Thisismorethentheallottednumberofcharacters");
3940 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3941 //test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3942 test_true(rc
== MEMCACHED_SUCCESS
);
3944 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3945 strcpy(long_key
, "This is more then the allotted number of characters");
3946 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3947 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3949 /* Test for a bad prefix, but with a short key */
3950 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3951 test_true(rc
== MEMCACHED_SUCCESS
);
3953 strcpy(long_key
, "dog cat");
3954 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3955 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3958 return TEST_SUCCESS
;
3962 #ifdef MEMCACHED_ENABLE_DEPRECATED
3963 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3965 void *test_ptr
= NULL
;
3968 memcached_malloc_fn malloc_cb
=
3969 (memcached_malloc_fn
)my_malloc
;
3970 cb_ptr
= *(void **)&malloc_cb
;
3971 memcached_return_t rc
;
3973 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
3974 test_true(rc
== MEMCACHED_SUCCESS
);
3975 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3976 test_true(rc
== MEMCACHED_SUCCESS
);
3977 test_true(test_ptr
== cb_ptr
);
3981 memcached_realloc_fn realloc_cb
=
3982 (memcached_realloc_fn
)my_realloc
;
3983 cb_ptr
= *(void **)&realloc_cb
;
3984 memcached_return_t rc
;
3986 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
3987 test_true(rc
== MEMCACHED_SUCCESS
);
3988 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3989 test_true(rc
== MEMCACHED_SUCCESS
);
3990 test_true(test_ptr
== cb_ptr
);
3994 memcached_free_fn free_cb
=
3995 (memcached_free_fn
)my_free
;
3996 cb_ptr
= *(void **)&free_cb
;
3997 memcached_return_t rc
;
3999 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
4000 test_true(rc
== MEMCACHED_SUCCESS
);
4001 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
4002 test_true(rc
== MEMCACHED_SUCCESS
);
4003 test_true(test_ptr
== cb_ptr
);
4006 return TEST_SUCCESS
;
4011 static test_return_t
set_memory_alloc(memcached_st
*memc
)
4013 memcached_return_t rc
;
4014 rc
= memcached_set_memory_allocators(memc
, NULL
, my_free
,
4015 my_realloc
, my_calloc
, NULL
);
4016 test_true(rc
== MEMCACHED_FAILURE
);
4018 rc
= memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
4019 my_realloc
, my_calloc
, NULL
);
4021 memcached_malloc_fn mem_malloc
;
4022 memcached_free_fn mem_free
;
4023 memcached_realloc_fn mem_realloc
;
4024 memcached_calloc_fn mem_calloc
;
4025 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
4026 &mem_realloc
, &mem_calloc
);
4028 test_true(mem_malloc
== my_malloc
);
4029 test_true(mem_realloc
== my_realloc
);
4030 test_true(mem_calloc
== my_calloc
);
4031 test_true(mem_free
== my_free
);
4033 return TEST_SUCCESS
;
4036 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
4039 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4040 memcached_hash_t hash
;
4041 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4042 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
4045 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4046 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4048 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4050 if (hash
!= MEMCACHED_HASH_CRC
)
4051 return TEST_SKIPPED
;
4053 return TEST_SUCCESS
;
4056 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
4059 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4060 memcached_hash_t hash
;
4061 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4062 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
4065 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4066 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4068 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4070 if (hash
!= MEMCACHED_HASH_HSIEH
)
4071 return TEST_SKIPPED
;
4074 return TEST_SUCCESS
;
4077 static test_return_t
enable_cas(memcached_st
*memc
)
4079 unsigned int set
= 1;
4081 if (libmemcached_util_version_check(memc
, 1, 2, 4))
4083 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
4085 return TEST_SUCCESS
;
4088 return TEST_SKIPPED
;
4091 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
4093 memcached_version(memc
);
4095 memcached_server_instance_st instance
=
4096 memcached_server_instance_by_position(memc
, 0);
4098 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
4099 || instance
->minor_version
> 2)
4101 return TEST_SUCCESS
;
4104 return TEST_SKIPPED
;
4107 static test_return_t
pre_unix_socket(memcached_st
*memc
)
4109 memcached_return_t rc
;
4112 memcached_servers_reset(memc
);
4114 if (stat("/tmp/memcached.socket", &buf
))
4115 return TEST_SKIPPED
;
4117 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
4119 return ( rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_FAILURE
);
4122 static test_return_t
pre_nodelay(memcached_st
*memc
)
4124 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
4125 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
4127 return TEST_SUCCESS
;
4130 static test_return_t
pre_settimer(memcached_st
*memc
)
4132 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4133 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4135 return TEST_SUCCESS
;
4138 static test_return_t
poll_timeout(memcached_st
*memc
)
4144 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4146 timeout
= (size_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
4148 test_true(timeout
== 100);
4150 return TEST_SUCCESS
;
4153 static test_return_t
noreply_test(memcached_st
*memc
)
4155 memcached_return_t ret
;
4156 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
4157 test_true(ret
== MEMCACHED_SUCCESS
);
4158 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4159 test_true(ret
== MEMCACHED_SUCCESS
);
4160 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
4161 test_true(ret
== MEMCACHED_SUCCESS
);
4162 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
4163 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
4164 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
4166 for (int count
=0; count
< 5; ++count
)
4168 for (size_t x
= 0; x
< 100; ++x
)
4171 size_t len
= (size_t)sprintf(key
, "%zu", x
);
4175 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4178 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4181 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4184 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4187 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4193 test_true(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
4197 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4198 ** API and is _ONLY_ done this way to verify that the library works the
4199 ** way it is supposed to do!!!!
4202 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4204 memcached_server_instance_st instance
=
4205 memcached_server_instance_by_position(memc
, x
);
4206 no_msg
+=(int)(instance
->cursor_active
);
4209 test_true(no_msg
== 0);
4210 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4213 ** Now validate that all items was set properly!
4215 for (size_t x
= 0; x
< 100; ++x
)
4219 size_t len
= (size_t)sprintf(key
, "%zu", x
);
4222 char* value
=memcached_get(memc
, key
, strlen(key
),
4223 &length
, &flags
, &ret
);
4224 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4227 case 0: /* FALLTHROUGH */
4228 case 1: /* FALLTHROUGH */
4230 test_true(strncmp(value
, key
, len
) == 0);
4231 test_true(len
== length
);
4234 test_true(length
== len
* 2);
4237 test_true(length
== len
* 3);
4247 /* Try setting an illegal cas value (should not return an error to
4248 * the caller (because we don't expect a return message from the server)
4250 const char* keys
[]= {"0"};
4251 size_t lengths
[]= {1};
4254 memcached_result_st results_obj
;
4255 memcached_result_st
*results
;
4256 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4257 test_true(ret
== MEMCACHED_SUCCESS
);
4259 results
= memcached_result_create(memc
, &results_obj
);
4261 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4263 test_true(ret
== MEMCACHED_SUCCESS
);
4264 uint64_t cas
= memcached_result_cas(results
);
4265 memcached_result_free(&results_obj
);
4267 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4268 test_true(ret
== MEMCACHED_SUCCESS
);
4271 * The item will have a new cas value, so try to set it again with the old
4272 * value. This should fail!
4274 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4275 test_true(ret
== MEMCACHED_SUCCESS
);
4276 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4277 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4278 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4281 return TEST_SUCCESS
;
4284 static test_return_t
analyzer_test(memcached_st
*memc
)
4286 memcached_return_t rc
;
4287 memcached_stat_st
*memc_stat
;
4288 memcached_analysis_st
*report
;
4290 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4291 test_true(rc
== MEMCACHED_SUCCESS
);
4292 test_true(memc_stat
);
4294 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4295 test_true(rc
== MEMCACHED_SUCCESS
);
4299 memcached_stat_free(NULL
, memc_stat
);
4301 return TEST_SUCCESS
;
4304 /* Count the objects */
4305 static memcached_return_t
callback_dump_counter(const memcached_st
*ptr
__attribute__((unused
)),
4306 const char *key
__attribute__((unused
)),
4307 size_t key_length
__attribute__((unused
)),
4310 size_t *counter
= (size_t *)context
;
4312 *counter
= *counter
+ 1;
4314 return MEMCACHED_SUCCESS
;
4317 static test_return_t
dump_test(memcached_st
*memc
)
4319 memcached_return_t rc
;
4321 memcached_dump_fn callbacks
[1];
4322 test_return_t main_rc
;
4324 callbacks
[0]= &callback_dump_counter
;
4326 /* No support for Binary protocol yet */
4327 if (memc
->flags
.binary_protocol
)
4328 return TEST_SUCCESS
;
4330 main_rc
= set_test3(memc
);
4332 test_true (main_rc
== TEST_SUCCESS
);
4334 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
4335 test_true(rc
== MEMCACHED_SUCCESS
);
4337 /* We may have more then 32 if our previous flush has not completed */
4338 test_true(counter
>= 32);
4340 return TEST_SUCCESS
;
4343 #ifdef HAVE_LIBMEMCACHEDUTIL
4344 static void* connection_release(void *arg
)
4347 memcached_pool_st
* pool
;
4352 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
4356 static test_return_t
connection_pool_test(memcached_st
*memc
)
4358 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, 10);
4359 test_true(pool
!= NULL
);
4360 memcached_st
* mmc
[10];
4361 memcached_return_t rc
;
4363 for (size_t x
= 0; x
< 10; ++x
)
4365 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4366 test_true(mmc
[x
] != NULL
);
4367 test_true(rc
== MEMCACHED_SUCCESS
);
4370 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4371 test_true(rc
== MEMCACHED_SUCCESS
);
4375 memcached_pool_st
* pool
;
4377 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
4378 pthread_create(&tid
, NULL
, connection_release
, &item
);
4379 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4380 test_true(rc
== MEMCACHED_SUCCESS
);
4381 pthread_join(tid
, NULL
);
4382 test_true(mmc
[9] == item
.mmc
);
4383 const char *key
= "key";
4384 size_t keylen
= strlen(key
);
4386 // verify that I can do ops with all connections
4387 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
4388 test_true(rc
== MEMCACHED_SUCCESS
);
4390 for (size_t x
= 0; x
< 10; ++x
)
4392 uint64_t number_value
;
4393 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
4394 test_true(rc
== MEMCACHED_SUCCESS
);
4395 test_true(number_value
== (x
+1));
4399 for (size_t x
= 0; x
< 10; ++x
)
4401 test_true(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
4405 /* verify that I can set behaviors on the pool when I don't have all
4406 * of the connections in the pool. It should however be enabled
4407 * when I push the item into the pool
4409 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4410 test_true(mmc
[0] != NULL
);
4412 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4413 test_true(rc
== MEMCACHED_SUCCESS
);
4415 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4416 test_true(mmc
[1] != NULL
);
4418 test_true(memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4419 test_true(memcached_pool_push(pool
, mmc
[1]) == MEMCACHED_SUCCESS
);
4420 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4422 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4423 test_true(memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4424 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4427 test_true(memcached_pool_destroy(pool
) == memc
);
4428 return TEST_SUCCESS
;
4431 static test_return_t
util_version_test(memcached_st
*memc
)
4435 if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4436 test_true(if_successful
== true);
4438 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4440 if (! if_successful
)
4442 memcached_server_fn callbacks
[1];
4443 memcached_version(memc
);
4445 memcached_version(memc
);
4447 callbacks
[0]= dump_server_information
;
4448 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4450 test_true(if_successful
== false);
4452 memcached_server_instance_st instance
=
4453 memcached_server_instance_by_position(memc
, 0);
4455 memcached_version(memc
);
4457 // We only use one binary when we test, so this should be just fine.
4458 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4459 test_true(if_successful
== true);
4461 if (instance
->micro_version
> 0)
4462 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4463 else if (instance
->minor_version
> 0)
4464 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4465 else if (instance
->major_version
> 0)
4466 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4468 test_true(if_successful
== true);
4470 if (instance
->micro_version
> 0)
4471 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4472 else if (instance
->minor_version
> 0)
4473 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4474 else if (instance
->major_version
> 0)
4475 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4477 test_true(if_successful
== false);
4479 return TEST_SUCCESS
;
4482 static test_return_t
ping_test(memcached_st
*memc
)
4484 memcached_return_t rc
;
4485 memcached_server_instance_st instance
=
4486 memcached_server_instance_by_position(memc
, 0);
4488 // Test both the version that returns a code, and the one that does not.
4489 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4490 memcached_server_port(instance
), NULL
));
4492 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4493 memcached_server_port(instance
), &rc
));
4495 test_true(rc
== MEMCACHED_SUCCESS
);
4497 return TEST_SUCCESS
;
4501 static test_return_t
replication_set_test(memcached_st
*memc
)
4503 memcached_return_t rc
;
4504 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4505 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
4507 rc
= memcached_set(memc
, "bubba", 5, "0", 1, 0, 0);
4508 test_true(rc
== MEMCACHED_SUCCESS
);
4511 ** We are using the quiet commands to store the replicas, so we need
4512 ** to ensure that all of them are processed before we can continue.
4513 ** In the test we go directly from storing the object to trying to
4514 ** receive the object from all of the different servers, so we
4515 ** could end up in a race condition (the memcached server hasn't yet
4516 ** processed the quiet command from the replication set when it process
4517 ** the request from the other client (created by the clone)). As a
4518 ** workaround for that we call memcached_quit to send the quit command
4519 ** to the server and wait for the response ;-) If you use the test code
4520 ** as an example for your own code, please note that you shouldn't need
4523 memcached_quit(memc
);
4526 ** "bubba" should now be stored on all of our servers. We don't have an
4527 ** easy to use API to address each individual server, so I'll just iterate
4528 ** through a bunch of "master keys" and I should most likely hit all of the
4531 for (int x
= 'a'; x
<= 'z'; ++x
)
4533 char key
[2]= { [0]= (char)x
};
4536 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
4538 test_true(rc
== MEMCACHED_SUCCESS
);
4539 test_true(val
!= NULL
);
4543 memcached_free(memc_clone
);
4545 return TEST_SUCCESS
;
4548 static test_return_t
replication_get_test(memcached_st
*memc
)
4550 memcached_return_t rc
;
4553 * Don't do the following in your code. I am abusing the internal details
4554 * within the library, and this is not a supported interface.
4555 * This is to verify correct behavior in the library
4557 for (uint32_t host
= 0; host
< memcached_server_count(memc
); ++host
)
4559 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4560 memcached_server_instance_st instance
=
4561 memcached_server_instance_by_position(memc_clone
, host
);
4563 ((memcached_server_write_instance_st
)instance
)->port
= 0;
4565 for (int x
= 'a'; x
<= 'z'; ++x
)
4567 char key
[2]= { [0]= (char)x
};
4570 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
4572 test_true(rc
== MEMCACHED_SUCCESS
);
4573 test_true(val
!= NULL
);
4577 memcached_free(memc_clone
);
4580 return TEST_SUCCESS
;
4583 static test_return_t
replication_mget_test(memcached_st
*memc
)
4585 memcached_return_t rc
;
4586 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4587 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
4589 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
4590 size_t len
[]= { 5, 4, 4, 4 };
4592 for (size_t x
= 0; x
< 4; ++x
)
4594 rc
= memcached_set(memc
, keys
[x
], len
[x
], "0", 1, 0, 0);
4595 test_true(rc
== MEMCACHED_SUCCESS
);
4599 ** We are using the quiet commands to store the replicas, so we need
4600 ** to ensure that all of them are processed before we can continue.
4601 ** In the test we go directly from storing the object to trying to
4602 ** receive the object from all of the different servers, so we
4603 ** could end up in a race condition (the memcached server hasn't yet
4604 ** processed the quiet command from the replication set when it process
4605 ** the request from the other client (created by the clone)). As a
4606 ** workaround for that we call memcached_quit to send the quit command
4607 ** to the server and wait for the response ;-) If you use the test code
4608 ** as an example for your own code, please note that you shouldn't need
4611 memcached_quit(memc
);
4614 * Don't do the following in your code. I am abusing the internal details
4615 * within the library, and this is not a supported interface.
4616 * This is to verify correct behavior in the library
4618 memcached_result_st result_obj
;
4619 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; host
++)
4621 memcached_st
*new_clone
= memcached_clone(NULL
, memc
);
4622 memcached_server_instance_st instance
=
4623 memcached_server_instance_by_position(new_clone
, host
);
4624 ((memcached_server_write_instance_st
)instance
)->port
= 0;
4626 for (int x
= 'a'; x
<= 'z'; ++x
)
4628 char key
[2]= { [0]= (char)x
, [1]= 0 };
4630 rc
= memcached_mget_by_key(new_clone
, key
, 1, keys
, len
, 4);
4631 test_true(rc
== MEMCACHED_SUCCESS
);
4633 memcached_result_st
*results
= memcached_result_create(new_clone
, &result_obj
);
4637 while ((results
= memcached_fetch_result(new_clone
, &result_obj
, &rc
)) != NULL
)
4641 test_true(hits
== 4);
4642 memcached_result_free(&result_obj
);
4645 memcached_free(new_clone
);
4648 memcached_free(memc_clone
);
4650 return TEST_SUCCESS
;
4653 static test_return_t
replication_randomize_mget_test(memcached_st
*memc
)
4655 memcached_result_st result_obj
;
4656 memcached_return_t rc
;
4657 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4658 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 3);
4659 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ
, 1);
4661 const char *keys
[]= { "key1", "key2", "key3", "key4", "key5", "key6", "key7" };
4662 size_t len
[]= { 4, 4, 4, 4, 4, 4, 4 };
4664 for (size_t x
= 0; x
< 7; ++x
)
4666 rc
= memcached_set(memc
, keys
[x
], len
[x
], "1", 1, 0, 0);
4667 test_true(rc
== MEMCACHED_SUCCESS
);
4670 memcached_quit(memc
);
4672 for (size_t x
= 0; x
< 7; ++x
)
4674 const char key
[2]= { [0]= (const char)x
};
4676 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 7);
4677 test_true(rc
== MEMCACHED_SUCCESS
);
4679 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4683 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4687 test_true(hits
== 7);
4688 memcached_result_free(&result_obj
);
4690 memcached_free(memc_clone
);
4691 return TEST_SUCCESS
;
4694 static test_return_t
replication_delete_test(memcached_st
*memc
)
4696 memcached_return_t rc
;
4697 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4698 /* Delete the items from all of the servers except 1 */
4699 uint64_t repl
= memcached_behavior_get(memc
,
4700 MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
4701 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, --repl
);
4703 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
4704 size_t len
[]= { 5, 4, 4, 4 };
4706 for (size_t x
= 0; x
< 4; ++x
)
4708 rc
= memcached_delete_by_key(memc
, keys
[0], len
[0], keys
[x
], len
[x
], 0);
4709 test_true(rc
== MEMCACHED_SUCCESS
);
4713 * Don't do the following in your code. I am abusing the internal details
4714 * within the library, and this is not a supported interface.
4715 * This is to verify correct behavior in the library
4717 uint32_t hash
= memcached_generate_hash(memc
, keys
[0], len
[0]);
4718 for (uint32_t x
= 0; x
< (repl
+ 1); ++x
)
4720 memcached_server_instance_st instance
=
4721 memcached_server_instance_by_position(memc_clone
, x
);
4723 ((memcached_server_write_instance_st
)instance
)->port
= 0;
4724 if (++hash
== memc_clone
->number_of_hosts
)
4728 memcached_result_st result_obj
;
4729 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; ++host
)
4731 for (size_t x
= 'a'; x
<= 'z'; ++x
)
4733 const char key
[2]= { [0]= (const char)x
};
4735 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 4);
4736 test_true(rc
== MEMCACHED_SUCCESS
);
4738 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4742 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4746 test_true(hits
== 4);
4747 memcached_result_free(&result_obj
);
4750 memcached_free(memc_clone
);
4752 return TEST_SUCCESS
;
4756 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4760 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4761 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4762 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4763 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4764 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4765 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4766 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4767 #ifdef HAVE_HSIEH_HASH
4768 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4770 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4771 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4772 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4774 return TEST_SUCCESS
;
4778 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4780 memcached_return_t expected_rc
= MEMCACHED_FAILURE
;
4781 #ifdef HAVE_HSIEH_HASH
4782 expected_rc
= MEMCACHED_SUCCESS
;
4784 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4785 (uint64_t)MEMCACHED_HASH_HSIEH
);
4786 test_true(rc
== expected_rc
);
4788 return TEST_SUCCESS
;
4791 static test_return_t
one_at_a_time_run (memcached_st
*memc
__attribute__((unused
)))
4796 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4800 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
);
4801 test_true(one_at_a_time_values
[x
] == hash_val
);
4804 return TEST_SUCCESS
;
4807 static test_return_t
md5_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_MD5
);
4817 test_true(md5_values
[x
] == hash_val
);
4820 return TEST_SUCCESS
;
4823 static test_return_t
crc_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_CRC
);
4833 test_true(crc_values
[x
] == hash_val
);
4836 return TEST_SUCCESS
;
4839 static test_return_t
fnv1_64_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_FNV1_64
);
4849 test_true(fnv1_64_values
[x
] == hash_val
);
4852 return TEST_SUCCESS
;
4855 static test_return_t
fnv1a_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_FNV1A_64
);
4865 test_true(fnv1a_64_values
[x
] == hash_val
);
4868 return TEST_SUCCESS
;
4871 static test_return_t
fnv1_32_run (memcached_st
*memc
__attribute__((unused
)))
4877 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4881 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4882 test_true(fnv1_32_values
[x
] == hash_val
);
4885 return TEST_SUCCESS
;
4888 static test_return_t
fnv1a_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_FNV1A_32
);
4898 test_true(fnv1a_32_values
[x
] == hash_val
);
4901 return TEST_SUCCESS
;
4904 static test_return_t
hsieh_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_HSIEH
);
4914 test_true(hsieh_values
[x
] == hash_val
);
4917 return TEST_SUCCESS
;
4920 static test_return_t
murmur_run (memcached_st
*memc
__attribute__((unused
)))
4922 #ifdef WORDS_BIGENDIAN
4923 return TEST_SKIPPED
;
4928 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4932 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
4933 test_true(murmur_values
[x
] == hash_val
);
4936 return TEST_SUCCESS
;
4940 static test_return_t
jenkins_run (memcached_st
*memc
__attribute__((unused
)))
4946 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4950 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4951 test_true(jenkins_values
[x
] == hash_val
);
4954 return TEST_SUCCESS
;
4957 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *context
)
4960 return libhashkit_md5(string
, string_length
);
4963 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *context
)
4966 return libhashkit_crc32(string
, string_length
);
4969 static test_return_t
memcached_get_hashkit_test (memcached_st
*memc
)
4973 const hashkit_st
*kit
;
4975 hashkit_return_t hash_rc
;
4977 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};
4978 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};
4980 kit
= memcached_get_hashkit(memc
);
4982 hashkit_clone(&new_kit
, kit
);
4983 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
);
4984 test_true(hash_rc
== HASHKIT_SUCCESS
);
4986 memcached_set_hashkit(memc
, &new_kit
);
4989 Verify Setting the hash.
4991 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4995 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4996 test_true(md5_values
[x
] == hash_val
);
5001 Now check memcached_st.
5003 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5007 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
5008 test_true(md5_hosts
[x
] == hash_val
);
5011 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
);
5012 test_true(hash_rc
== HASHKIT_SUCCESS
);
5014 memcached_set_hashkit(memc
, &new_kit
);
5017 Verify Setting the hash.
5019 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5023 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
5024 test_true(crc_values
[x
] == hash_val
);
5027 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5031 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
5032 test_true(crc_hosts
[x
] == hash_val
);
5035 return TEST_SUCCESS
;
5039 Test case adapted from John Gorman <johngorman2@gmail.com>
5041 We are testing the error condition when we connect to a server via memcached_get()
5042 but find that the server is not available.
5044 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*memc
)
5047 memcached_st
*tl_memc_h
;
5048 memcached_server_st
*servers
;
5050 const char *key
= "MemcachedLives";
5053 memcached_return rc
;
5057 tl_memc_h
= memcached_create(NULL
);
5058 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
5059 memcached_server_push(tl_memc_h
, servers
);
5060 memcached_server_list_free(servers
);
5062 // See if memcached is reachable.
5063 value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
5066 test_true(len
== 0);
5067 test_false(rc
== MEMCACHED_SUCCESS
);
5069 memcached_free(tl_memc_h
);
5071 return TEST_SUCCESS
;
5075 We connect to a server which exists, but search for a key that does not exist.
5077 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
5079 const char *key
= "MemcachedKeyNotEXIST";
5082 memcached_return rc
;
5085 // See if memcached is reachable.
5086 value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
5089 test_true(len
== 0);
5090 test_true(rc
== MEMCACHED_NOTFOUND
);
5092 return TEST_SUCCESS
;
5096 Test case adapted from John Gorman <johngorman2@gmail.com>
5098 We are testing the error condition when we connect to a server via memcached_get_by_key()
5099 but find that the server is not available.
5101 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
5104 memcached_st
*tl_memc_h
;
5105 memcached_server_st
*servers
;
5107 const char *key
= "MemcachedLives";
5110 memcached_return rc
;
5114 tl_memc_h
= memcached_create(NULL
);
5115 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
5116 memcached_server_push(tl_memc_h
, servers
);
5117 memcached_server_list_free(servers
);
5119 // See if memcached is reachable.
5120 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
5123 test_true(len
== 0);
5124 test_false(rc
== MEMCACHED_SUCCESS
);
5126 memcached_free(tl_memc_h
);
5128 return TEST_SUCCESS
;
5132 We connect to a server which exists, but search for a key that does not exist.
5134 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
5136 const char *key
= "MemcachedKeyNotEXIST";
5139 memcached_return rc
;
5142 // See if memcached is reachable.
5143 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
5146 test_true(len
== 0);
5147 test_true(rc
== MEMCACHED_NOTFOUND
);
5149 return TEST_SUCCESS
;
5153 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*trash
)
5155 memcached_return_t rc
;
5158 memcached_server_st
*server_pool
;
5163 memc
= memcached_create(NULL
);
5166 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5167 test_true(rc
== MEMCACHED_SUCCESS
);
5169 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5170 test_true(value
== 1);
5172 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
) == MEMCACHED_SUCCESS
);
5173 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
);
5176 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");
5177 memcached_server_push(memc
, server_pool
);
5179 /* verify that the server list was parsed okay. */
5180 test_true(memcached_server_count(memc
) == 8);
5181 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5182 test_true(server_pool
[0].port
== 11211);
5183 test_true(server_pool
[0].weight
== 600);
5184 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5185 test_true(server_pool
[2].port
== 11211);
5186 test_true(server_pool
[2].weight
== 200);
5187 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5188 test_true(server_pool
[7].port
== 11211);
5189 test_true(server_pool
[7].weight
== 100);
5191 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5192 * us test the boundary wraparound.
5194 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5196 /* verify the standard ketama set. */
5197 for (x
= 0; x
< 99; x
++)
5199 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
5200 memcached_server_instance_st instance
=
5201 memcached_server_instance_by_position(memc
, server_idx
);
5202 const char *hostname
= memcached_server_name(instance
);
5204 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
5207 memcached_server_list_free(server_pool
);
5208 memcached_free(memc
);
5210 return TEST_SUCCESS
;
5213 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*trash
)
5215 memcached_return_t rc
;
5218 memcached_server_st
*server_pool
;
5223 memc
= memcached_create(NULL
);
5226 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5227 test_true(rc
== MEMCACHED_SUCCESS
);
5229 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5230 test_true(value
== 1);
5232 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
5233 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
);
5235 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");
5236 memcached_server_push(memc
, server_pool
);
5238 /* verify that the server list was parsed okay. */
5239 test_true(memcached_server_count(memc
) == 8);
5240 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5241 test_true(server_pool
[0].port
== 11211);
5242 test_true(server_pool
[0].weight
== 600);
5243 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5244 test_true(server_pool
[2].port
== 11211);
5245 test_true(server_pool
[2].weight
== 200);
5246 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5247 test_true(server_pool
[7].port
== 11211);
5248 test_true(server_pool
[7].weight
== 100);
5250 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5251 * us test the boundary wraparound.
5253 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5255 /* verify the standard ketama set. */
5256 for (x
= 0; x
< 99; x
++)
5258 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
5260 memcached_server_instance_st instance
=
5261 memcached_server_instance_by_position(memc
, server_idx
);
5263 const char *hostname
= memcached_server_name(instance
);
5265 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
5268 memcached_server_list_free(server_pool
);
5269 memcached_free(memc
);
5271 return TEST_SUCCESS
;
5274 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5276 test_return_t test_rc
;
5277 test_rc
= pre_binary(memc
);
5279 if (test_rc
!= TEST_SUCCESS
)
5282 memcached_return_t ret
;
5283 const char *key
= "regression_bug_434484";
5284 size_t keylen
= strlen(key
);
5286 ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5287 test_true(ret
== MEMCACHED_NOTSTORED
);
5289 size_t size
= 2048 * 1024;
5290 void *data
= calloc(1, size
);
5291 test_true(data
!= NULL
);
5292 ret
= memcached_set(memc
, key
, keylen
, data
, size
, 0, 0);
5293 test_true(ret
== MEMCACHED_E2BIG
);
5296 return TEST_SUCCESS
;
5299 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5301 test_return_t test_rc
;
5302 test_rc
= pre_binary(memc
);
5304 if (test_rc
!= TEST_SUCCESS
)
5307 memcached_return_t rc
;
5309 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5312 * I only want to hit only _one_ server so I know the number of requests I'm
5313 * sending in the pipleine to the server. Let's try to do a multiget of
5314 * 1024 (that should satisfy most users don't you think?). Future versions
5315 * will include a mget_execute function call if you need a higher number.
5317 uint32_t number_of_hosts
= memcached_server_count(memc
);
5318 memc
->number_of_hosts
= 1;
5319 const size_t max_keys
= 1024;
5320 char **keys
= calloc(max_keys
, sizeof(char*));
5321 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5323 for (size_t x
= 0; x
< max_keys
; ++x
)
5327 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5329 test_true(keys
[x
] != NULL
);
5333 * Run two times.. the first time we should have 100% cache miss,
5334 * and the second time we should have 100% cache hits
5336 for (size_t y
= 0; y
< 2; y
++)
5338 rc
= memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
);
5339 test_true(rc
== MEMCACHED_SUCCESS
);
5340 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5344 /* The first iteration should give me a 100% cache miss. verify that*/
5345 char blob
[1024]= { 0 };
5347 test_true(counter
== 0);
5349 for (size_t x
= 0; x
< max_keys
; ++x
)
5351 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5352 blob
, sizeof(blob
), 0, 0);
5353 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5358 /* Verify that we received all of the key/value pairs */
5359 test_true(counter
== max_keys
);
5363 /* Release allocated resources */
5364 for (size_t x
= 0; x
< max_keys
; ++x
)
5371 memc
->number_of_hosts
= number_of_hosts
;
5373 return TEST_SUCCESS
;
5376 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5378 memcached_return_t rc
;
5379 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5380 test_true(rc
== MEMCACHED_SUCCESS
);
5382 return regression_bug_434843(memc
);
5385 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5387 memcached_return_t rc
;
5388 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5389 test_true(rc
== MEMCACHED_SUCCESS
);
5391 char *bytes
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5392 test_true(rc
== MEMCACHED_SUCCESS
);
5393 test_true(bytes
!= NULL
);
5394 char *bytes_read
= memcached_stat_get_value(memc
, memc_stat
,
5396 test_true(rc
== MEMCACHED_SUCCESS
);
5397 test_true(bytes_read
!= NULL
);
5399 char *bytes_written
= memcached_stat_get_value(memc
, memc_stat
,
5400 "bytes_written", &rc
);
5401 test_true(rc
== MEMCACHED_SUCCESS
);
5402 test_true(bytes_written
!= NULL
);
5404 test_true(strcmp(bytes
, bytes_read
) != 0);
5405 test_true(strcmp(bytes
, bytes_written
) != 0);
5407 /* Release allocated resources */
5410 free(bytes_written
);
5411 memcached_stat_free(NULL
, memc_stat
);
5413 return TEST_SUCCESS
;
5417 * The test case isn't obvious so I should probably document why
5418 * it works the way it does. Bug 442914 was caused by a bug
5419 * in the logic in memcached_purge (it did not handle the case
5420 * where the number of bytes sent was equal to the watermark).
5421 * In this test case, create messages so that we hit that case
5422 * and then disable noreply mode and issue a new command to
5423 * verify that it isn't stuck. If we change the format for the
5424 * delete command or the watermarks, we need to update this
5427 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5429 memcached_return_t rc
;
5430 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
5431 test_true(rc
== MEMCACHED_SUCCESS
);
5432 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5434 uint32_t number_of_hosts
= memcached_server_count(memc
);
5435 memc
->number_of_hosts
= 1;
5440 for (uint32_t x
= 0; x
< 250; ++x
)
5442 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5443 rc
= memcached_delete(memc
, k
, len
, 0);
5444 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5447 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5450 rc
= memcached_delete(memc
, k
, len
, 0);
5451 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5453 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0);
5454 test_true(rc
== MEMCACHED_SUCCESS
);
5455 rc
= memcached_delete(memc
, k
, len
, 0);
5456 test_true(rc
== MEMCACHED_NOTFOUND
);
5458 memc
->number_of_hosts
= number_of_hosts
;
5460 return TEST_SUCCESS
;
5463 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5465 memcached_server_instance_st instance_one
;
5466 memcached_server_instance_st instance_two
;
5468 if (memcached_server_count(memc
) < 3 || pre_replication(memc
) != TEST_SUCCESS
)
5469 return TEST_SKIPPED
;
5471 memcached_return_t rc
;
5473 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2);
5474 test_true(rc
== MEMCACHED_SUCCESS
);
5476 const size_t max_keys
= 100;
5477 char **keys
= calloc(max_keys
, sizeof(char*));
5478 size_t *key_length
= calloc(max_keys
, sizeof(size_t));
5480 for (size_t x
= 0; x
< max_keys
; ++x
)
5484 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5486 test_true(keys
[x
] != NULL
);
5487 rc
= memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0);
5488 test_true(rc
== MEMCACHED_SUCCESS
);
5492 ** We are using the quiet commands to store the replicas, so we need
5493 ** to ensure that all of them are processed before we can continue.
5494 ** In the test we go directly from storing the object to trying to
5495 ** receive the object from all of the different servers, so we
5496 ** could end up in a race condition (the memcached server hasn't yet
5497 ** processed the quiet command from the replication set when it process
5498 ** the request from the other client (created by the clone)). As a
5499 ** workaround for that we call memcached_quit to send the quit command
5500 ** to the server and wait for the response ;-) If you use the test code
5501 ** as an example for your own code, please note that you shouldn't need
5504 memcached_quit(memc
);
5506 /* Verify that all messages are stored, and we didn't stuff too much
5509 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5510 test_true(rc
== MEMCACHED_SUCCESS
);
5513 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5514 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5515 /* Verify that we received all of the key/value pairs */
5516 test_true(counter
== max_keys
);
5518 memcached_quit(memc
);
5520 * Don't do the following in your code. I am abusing the internal details
5521 * within the library, and this is not a supported interface.
5522 * This is to verify correct behavior in the library. Fake that two servers
5525 instance_one
= memcached_server_instance_by_position(memc
, 0);
5526 instance_two
= memcached_server_instance_by_position(memc
, 2);
5527 in_port_t port0
= instance_one
->port
;
5528 in_port_t port2
= instance_two
->port
;
5530 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5531 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5533 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5534 test_true(rc
== MEMCACHED_SUCCESS
);
5537 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5538 test_true(counter
== (unsigned int)max_keys
);
5540 /* restore the memc handle */
5541 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5542 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5544 memcached_quit(memc
);
5546 /* Remove half of the objects */
5547 for (size_t x
= 0; x
< max_keys
; ++x
)
5551 rc
= memcached_delete(memc
, keys
[x
], key_length
[x
], 0);
5552 test_true(rc
== MEMCACHED_SUCCESS
);
5556 memcached_quit(memc
);
5557 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5558 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5560 /* now retry the command, this time we should have cache misses */
5561 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5562 test_true(rc
== MEMCACHED_SUCCESS
);
5565 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5566 test_true(counter
== (unsigned int)(max_keys
>> 1));
5568 /* Release allocated resources */
5569 for (size_t x
= 0; x
< max_keys
; ++x
)
5576 /* restore the memc handle */
5577 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5578 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5580 return TEST_SUCCESS
;
5583 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5585 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5586 test_true(memc_clone
!= NULL
);
5587 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5589 memcached_server_instance_st instance
=
5590 memcached_server_instance_by_position(memc_clone
, 0);
5592 if (instance
->major_version
> 1 ||
5593 (instance
->major_version
== 1 &&
5594 instance
->minor_version
> 2))
5596 /* Binary protocol doesn't support deferred delete */
5597 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5598 test_true(bin_clone
!= NULL
);
5599 test_true(memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1) == MEMCACHED_SUCCESS
);
5600 test_true(memcached_delete(bin_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5601 memcached_free(bin_clone
);
5603 memcached_quit(memc_clone
);
5605 /* If we know the server version, deferred delete should fail
5606 * with invalid arguments */
5607 test_true(memcached_delete(memc_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5609 /* If we don't know the server version, we should get a protocol error */
5610 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5612 /* but there is a bug in some of the memcached servers (1.4) that treats
5613 * the counter as noreply so it doesn't send the proper error message
5615 test_true(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5617 /* And buffered mode should be disabled and we should get protocol error */
5618 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5619 rc
= memcached_delete(memc
, "foo", 3, 1);
5620 test_true(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5622 /* Same goes for noreply... */
5623 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1) == MEMCACHED_SUCCESS
);
5624 rc
= memcached_delete(memc
, "foo", 3, 1);
5625 test_true(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5627 /* but a normal request should go through (and be buffered) */
5628 test_true((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_BUFFERED
);
5629 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
5631 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0) == MEMCACHED_SUCCESS
);
5632 /* unbuffered noreply should be success */
5633 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_SUCCESS
);
5634 /* unbuffered with reply should be not found... */
5635 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0) == MEMCACHED_SUCCESS
);
5636 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_NOTFOUND
);
5639 memcached_free(memc_clone
);
5640 return TEST_SUCCESS
;
5644 /* Test memcached_server_get_last_disconnect
5645 * For a working server set, shall be NULL
5646 * For a set of non existing server, shall not be NULL
5648 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5650 memcached_return_t rc
;
5651 memcached_server_instance_st disconnected_server
;
5653 /* With the working set of server */
5654 const char *key
= "marmotte";
5655 const char *value
= "milka";
5657 memcached_reset_last_disconnected_server(memc
);
5658 rc
= memcached_set(memc
, key
, strlen(key
),
5659 value
, strlen(value
),
5660 (time_t)0, (uint32_t)0);
5661 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5663 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5664 test_true(disconnected_server
== NULL
);
5666 /* With a non existing server */
5668 memcached_server_st
*servers
;
5670 const char *server_list
= "localhost:9";
5672 servers
= memcached_servers_parse(server_list
);
5674 mine
= memcached_create(NULL
);
5675 rc
= memcached_server_push(mine
, servers
);
5676 test_true(rc
== MEMCACHED_SUCCESS
);
5677 memcached_server_list_free(servers
);
5680 rc
= memcached_set(mine
, key
, strlen(key
),
5681 value
, strlen(value
),
5682 (time_t)0, (uint32_t)0);
5683 test_true(rc
!= MEMCACHED_SUCCESS
);
5685 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5686 if (disconnected_server
== NULL
)
5688 fprintf(stderr
, "RC %s\n", memcached_strerror(mine
, rc
));
5691 test_true(disconnected_server
!= NULL
);
5692 test_true(memcached_server_port(disconnected_server
)== 9);
5693 test_true(strncmp(memcached_server_name(disconnected_server
),"localhost",9) == 0);
5695 memcached_quit(mine
);
5696 memcached_free(mine
);
5698 return TEST_SUCCESS
;
5701 static test_return_t
test_verbosity(memcached_st
*memc
)
5703 memcached_verbosity(memc
, 3);
5705 return TEST_SUCCESS
;
5708 static test_return_t
test_server_failure(memcached_st
*memc
)
5710 memcached_st
*local_memc
;
5711 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
5713 local_memc
= memcached_create(NULL
);
5715 memcached_server_add(local_memc
, memcached_server_name(instance
), memcached_server_port(instance
));
5716 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 2);
5718 uint32_t server_count
= memcached_server_count(local_memc
);
5720 test_true(server_count
== 1);
5722 // Disable the server
5723 instance
= memcached_server_instance_by_position(local_memc
, 0);
5724 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 2;
5726 memcached_return_t rc
;
5727 rc
= memcached_set(local_memc
, "foo", strlen("foo"),
5729 (time_t)0, (uint32_t)0);
5730 test_true(rc
== MEMCACHED_SERVER_MARKED_DEAD
);
5732 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5733 rc
= memcached_set(local_memc
, "foo", strlen("foo"),
5735 (time_t)0, (uint32_t)0);
5736 test_true(rc
== MEMCACHED_SUCCESS
);
5739 memcached_free(local_memc
);
5741 return TEST_SUCCESS
;
5744 static test_return_t
test_cull_servers(memcached_st
*memc
)
5746 uint32_t count
= memcached_server_count(memc
);
5748 // Do not do this in your code, it is not supported.
5749 memc
->servers
[1].state
.is_dead
= true;
5750 memc
->state
.is_time_for_rebuild
= true;
5752 uint32_t new_count
= memcached_server_count(memc
);
5753 test_true(count
== new_count
);
5756 test_true(count
== new_count
+ 1 );
5759 return TEST_SUCCESS
;
5763 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5764 const char *key
, size_t key_length
,
5765 const char *value
, size_t value_length
,
5775 return MEMCACHED_SUCCESS
;
5778 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5780 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5781 test_true(rc
== MEMCACHED_SUCCESS
);
5783 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5784 test_true(rc
== MEMCACHED_SUCCESS
);
5786 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5787 test_true(rc
== MEMCACHED_SUCCESS
);
5789 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5790 test_true(rc
== MEMCACHED_SUCCESS
);
5792 return TEST_SUCCESS
;
5796 * This test ensures that the failure counter isn't incremented during
5797 * normal termination of the memcached instance.
5799 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5801 memcached_return_t rc
;
5802 memcached_server_instance_st instance
;
5804 /* Set value to force connection to the server */
5805 const char *key
= "marmotte";
5806 const char *value
= "milka";
5809 * Please note that I'm abusing the internal structures in libmemcached
5810 * in a non-portable way and you shouldn't be doing this. I'm only
5811 * doing this in order to verify that the library works the way it should
5813 uint32_t number_of_hosts
= memcached_server_count(memc
);
5814 memc
->number_of_hosts
= 1;
5816 /* Ensure that we are connected to the server by setting a value */
5817 rc
= memcached_set(memc
, key
, strlen(key
),
5818 value
, strlen(value
),
5819 (time_t)0, (uint32_t)0);
5820 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5823 instance
= memcached_server_instance_by_position(memc
, 0);
5824 /* The test is to see that the memcached_quit doesn't increase the
5825 * the server failure conter, so let's ensure that it is zero
5826 * before sending quit
5828 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5830 memcached_quit(memc
);
5832 /* Verify that it memcached_quit didn't increment the failure counter
5833 * Please note that this isn't bullet proof, because an error could
5836 test_true(instance
->server_failure_counter
== 0);
5838 /* restore the instance */
5839 memc
->number_of_hosts
= number_of_hosts
;
5841 return TEST_SUCCESS
;
5848 * Test that ensures mget_execute does not end into recursive calls that finally fails
5850 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5852 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5853 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5854 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5855 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5856 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5859 return TEST_SKIPPED
; // My MAC can't handle this test
5863 * I only want to hit _one_ server so I know the number of requests I'm
5864 * sending in the pipeline.
5866 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5867 memc
->number_of_hosts
= 1;
5868 size_t max_keys
= 20480;
5871 char **keys
= calloc(max_keys
, sizeof(char*));
5872 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5874 /* First add all of the items.. */
5876 char blob
[1024]= { 0 };
5877 memcached_return rc
;
5878 for (size_t x
= 0; x
< max_keys
; ++x
)
5881 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5883 assert(keys
[x
] != NULL
);
5884 rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5886 if (rc
== MEMCACHED_SERVER_MARKED_DEAD
)
5888 break; // We are out of business
5891 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
); // MEMCACHED_TIMEOUT <-- only observed on OSX
5893 if (rc
== MEMCACHED_TIMEOUT
&& slept
== false)
5896 sleep(1);// We will try to sleep
5899 else if (rc
== MEMCACHED_TIMEOUT
&& slept
== true)
5901 // We failed to send everything.
5906 if (rc
!= MEMCACHED_SERVER_MARKED_DEAD
)
5909 /* Try to get all of them with a large multiget */
5911 memcached_execute_function callbacks
[1]= { [0]= &callback_counter
};
5912 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5913 (size_t)max_keys
, callbacks
, &counter
, 1);
5915 assert(rc
== MEMCACHED_SUCCESS
);
5916 char* the_value
= NULL
;
5917 char the_key
[MEMCACHED_MAX_KEY
];
5918 size_t the_key_length
;
5919 size_t the_value_length
;
5923 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5925 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5931 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5934 assert(rc
== MEMCACHED_END
);
5936 /* Verify that we got all of the items */
5937 assert(counter
== max_keys
);
5940 /* Release all allocated resources */
5941 for (size_t x
= 0; x
< max_keys
; ++x
)
5948 memc
->number_of_hosts
= number_of_hosts
;
5950 return TEST_SUCCESS
;
5953 static test_return_t
regression_bug_583031(memcached_st
*unused
)
5957 memcached_st
*memc
= memcached_create(NULL
);
5959 memcached_server_add(memc
, "10.2.3.4", 11211);
5961 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5962 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5963 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5964 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5965 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5966 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5968 memcached_return_t rc
;
5972 (void)memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5974 test_true(rc
== MEMCACHED_TIMEOUT
);
5976 memcached_free(memc
);
5978 return TEST_SUCCESS
;
5981 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5983 fprintf(stderr
, "Iteration #%u: ", it
);
5985 if(error
== MEMCACHED_ERRNO
)
5987 fprintf(stderr
, "system error %d from %s: %s\n",
5988 errno
, what
, strerror(errno
));
5992 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5993 memcached_strerror(mc
, error
));
5997 #define TEST_CONSTANT_CREATION 200
5999 static test_return_t
regression_bug_(memcached_st
*memc
)
6001 const char *remote_server
;
6004 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
6006 return TEST_SKIPPED
;
6009 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
6011 memcached_st
* mc
= memcached_create(NULL
);
6012 memcached_return rc
;
6014 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
6015 if (rc
!= MEMCACHED_SUCCESS
)
6017 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6020 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
6021 if (rc
!= MEMCACHED_SUCCESS
)
6023 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6026 rc
= memcached_server_add(mc
, remote_server
, 0);
6027 if (rc
!= MEMCACHED_SUCCESS
)
6029 memcached_die(mc
, rc
, "memcached_server_add", x
);
6032 const char *set_key
= "akey";
6033 const size_t set_key_len
= strlen(set_key
);
6034 const char *set_value
= "a value";
6035 const size_t set_value_len
= strlen(set_value
);
6037 if (rc
== MEMCACHED_SUCCESS
)
6041 size_t get_value_len
;
6043 uint32_t get_value_flags
;
6045 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
6046 &get_value_flags
, &rc
);
6047 if (rc
!= MEMCACHED_SUCCESS
)
6049 memcached_die(mc
, rc
, "memcached_get", x
);
6055 (get_value_len
!= set_value_len
6056 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
6058 fprintf(stderr
, "Values don't match?\n");
6059 rc
= MEMCACHED_FAILURE
;
6065 rc
= memcached_set(mc
,
6066 set_key
, set_key_len
,
6067 set_value
, set_value_len
,
6071 if (rc
!= MEMCACHED_SUCCESS
)
6073 memcached_die(mc
, rc
, "memcached_set", x
);
6080 if (rc
!= MEMCACHED_SUCCESS
)
6086 return TEST_SUCCESS
;
6090 * Test that the sasl authentication works. We cannot use the default
6091 * pool of servers, because that would require that all servers we want
6092 * to test supports SASL authentication, and that they use the default
6095 static test_return_t
sasl_auth_test(memcached_st
*memc
)
6097 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
6098 memcached_return_t rc
;
6100 rc
= memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
6101 test_true(rc
== MEMCACHED_SUCCESS
);
6102 test_true((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_SUCCESS
);
6103 test_true((rc
= memcached_destroy_sasl_auth_data(memc
)) == MEMCACHED_SUCCESS
);
6104 test_true((rc
= memcached_destroy_sasl_auth_data(memc
)) == MEMCACHED_FAILURE
);
6105 test_true((rc
= memcached_destroy_sasl_auth_data(NULL
)) == MEMCACHED_FAILURE
);
6106 memcached_quit(memc
);
6108 rc
= memcached_set_sasl_auth_data(memc
,
6109 getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
6110 getenv("LIBMEMCACHED_TEST_SASL_SERVER"));
6111 test_true(rc
== MEMCACHED_SUCCESS
);
6113 rc
= memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
6114 test_true(rc
== MEMCACHED_AUTH_FAILURE
);
6115 test_true(memcached_destroy_sasl_auth_data(memc
) == MEMCACHED_SUCCESS
);
6117 memcached_quit(memc
);
6118 return TEST_SUCCESS
;
6121 return TEST_FAILURE
;
6125 /* Clean the server before beginning testing */
6127 {"util_version", 1, (test_callback_fn
)util_version_test
},
6128 {"flush", 0, (test_callback_fn
)flush_test
},
6129 {"init", 0, (test_callback_fn
)init_test
},
6130 {"allocation", 0, (test_callback_fn
)allocation_test
},
6131 {"server_list_null_test", 0, (test_callback_fn
)server_list_null_test
},
6132 {"server_unsort", 0, (test_callback_fn
)server_unsort_test
},
6133 {"server_sort", 0, (test_callback_fn
)server_sort_test
},
6134 {"server_sort2", 0, (test_callback_fn
)server_sort2_test
},
6135 {"memcached_server_remove", 0, (test_callback_fn
)memcached_server_remove_test
},
6136 {"clone_test", 0, (test_callback_fn
)clone_test
},
6137 {"connection_test", 0, (test_callback_fn
)connection_test
},
6138 {"callback_test", 0, (test_callback_fn
)callback_test
},
6139 {"userdata_test", 0, (test_callback_fn
)userdata_test
},
6140 {"error", 0, (test_callback_fn
)error_test
},
6141 {"set", 0, (test_callback_fn
)set_test
},
6142 {"set2", 0, (test_callback_fn
)set_test2
},
6143 {"set3", 0, (test_callback_fn
)set_test3
},
6144 {"dump", 1, (test_callback_fn
)dump_test
},
6145 {"add", 1, (test_callback_fn
)add_test
},
6146 {"replace", 1, (test_callback_fn
)replace_test
},
6147 {"delete", 1, (test_callback_fn
)delete_test
},
6148 {"get", 1, (test_callback_fn
)get_test
},
6149 {"get2", 0, (test_callback_fn
)get_test2
},
6150 {"get3", 0, (test_callback_fn
)get_test3
},
6151 {"get4", 0, (test_callback_fn
)get_test4
},
6152 {"partial mget", 0, (test_callback_fn
)get_test5
},
6153 {"stats_servername", 0, (test_callback_fn
)stats_servername_test
},
6154 {"increment", 0, (test_callback_fn
)increment_test
},
6155 {"increment_with_initial", 1, (test_callback_fn
)increment_with_initial_test
},
6156 {"decrement", 0, (test_callback_fn
)decrement_test
},
6157 {"decrement_with_initial", 1, (test_callback_fn
)decrement_with_initial_test
},
6158 {"increment_by_key", 0, (test_callback_fn
)increment_by_key_test
},
6159 {"increment_with_initial_by_key", 1, (test_callback_fn
)increment_with_initial_by_key_test
},
6160 {"decrement_by_key", 0, (test_callback_fn
)decrement_by_key_test
},
6161 {"decrement_with_initial_by_key", 1, (test_callback_fn
)decrement_with_initial_by_key_test
},
6162 {"quit", 0, (test_callback_fn
)quit_test
},
6163 {"mget", 1, (test_callback_fn
)mget_test
},
6164 {"mget_result", 1, (test_callback_fn
)mget_result_test
},
6165 {"mget_result_alloc", 1, (test_callback_fn
)mget_result_alloc_test
},
6166 {"mget_result_function", 1, (test_callback_fn
)mget_result_function
},
6167 {"mget_execute", 1, (test_callback_fn
)mget_execute
},
6168 {"mget_end", 0, (test_callback_fn
)mget_end
},
6169 {"get_stats", 0, (test_callback_fn
)get_stats
},
6170 {"add_host_test", 0, (test_callback_fn
)add_host_test
},
6171 {"add_host_test_1", 0, (test_callback_fn
)add_host_test1
},
6172 {"get_stats_keys", 0, (test_callback_fn
)get_stats_keys
},
6173 {"version_string_test", 0, (test_callback_fn
)version_string_test
},
6174 {"bad_key", 1, (test_callback_fn
)bad_key_test
},
6175 {"memcached_server_cursor", 1, (test_callback_fn
)memcached_server_cursor_test
},
6176 {"read_through", 1, (test_callback_fn
)read_through
},
6177 {"delete_through", 1, (test_callback_fn
)delete_through
},
6178 {"noreply", 1, (test_callback_fn
)noreply_test
},
6179 {"analyzer", 1, (test_callback_fn
)analyzer_test
},
6180 #ifdef HAVE_LIBMEMCACHEDUTIL
6181 {"connectionpool", 1, (test_callback_fn
)connection_pool_test
},
6182 {"ping", 1, (test_callback_fn
)ping_test
},
6184 {"test_get_last_disconnect", 1, (test_callback_fn
)test_get_last_disconnect
},
6185 {"verbosity", 1, (test_callback_fn
)test_verbosity
},
6186 {"test_server_failure", 1, (test_callback_fn
)test_server_failure
},
6187 {"cull_servers", 1, (test_callback_fn
)test_cull_servers
},
6188 {"memcached_stat_execute", 1, (test_callback_fn
)memcached_stat_execute_test
},
6192 test_st behavior_tests
[] ={
6193 {"behavior_test", 0, (test_callback_fn
)behavior_test
},
6194 {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_CORK_test
},
6195 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
6196 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
6200 test_st regression_binary_vs_block
[] ={
6201 {"block add", 1, (test_callback_fn
)block_add_regression
},
6202 {"binary add", 1, (test_callback_fn
)binary_add_regression
},
6206 test_st async_tests
[] ={
6207 {"add", 1, (test_callback_fn
)add_wrapper
},
6211 test_st string_tests
[] ={
6212 {"string static with null", 0, (test_callback_fn
)string_static_null
},
6213 {"string alloc with null", 0, (test_callback_fn
)string_alloc_null
},
6214 {"string alloc with 1K", 0, (test_callback_fn
)string_alloc_with_size
},
6215 {"string alloc with malloc failure", 0, (test_callback_fn
)string_alloc_with_size_toobig
},
6216 {"string append", 0, (test_callback_fn
)string_alloc_append
},
6217 {"string append failure (too big)", 0, (test_callback_fn
)string_alloc_append_toobig
},
6218 {0, 0, (test_callback_fn
)0}
6221 test_st result_tests
[] ={
6222 {"result static", 0, (test_callback_fn
)result_static
},
6223 {"result alloc", 0, (test_callback_fn
)result_alloc
},
6224 {0, 0, (test_callback_fn
)0}
6227 test_st version_1_2_3
[] ={
6228 {"append", 0, (test_callback_fn
)append_test
},
6229 {"prepend", 0, (test_callback_fn
)prepend_test
},
6230 {"cas", 0, (test_callback_fn
)cas_test
},
6231 {"cas2", 0, (test_callback_fn
)cas2_test
},
6232 {"append_binary", 0, (test_callback_fn
)append_binary_test
},
6233 {0, 0, (test_callback_fn
)0}
6236 test_st user_tests
[] ={
6237 {"user_supplied_bug1", 0, (test_callback_fn
)user_supplied_bug1
},
6238 {"user_supplied_bug2", 0, (test_callback_fn
)user_supplied_bug2
},
6239 {"user_supplied_bug3", 0, (test_callback_fn
)user_supplied_bug3
},
6240 {"user_supplied_bug4", 0, (test_callback_fn
)user_supplied_bug4
},
6241 {"user_supplied_bug5", 1, (test_callback_fn
)user_supplied_bug5
},
6242 {"user_supplied_bug6", 1, (test_callback_fn
)user_supplied_bug6
},
6243 {"user_supplied_bug7", 1, (test_callback_fn
)user_supplied_bug7
},
6244 {"user_supplied_bug8", 1, (test_callback_fn
)user_supplied_bug8
},
6245 {"user_supplied_bug9", 1, (test_callback_fn
)user_supplied_bug9
},
6246 {"user_supplied_bug10", 1, (test_callback_fn
)user_supplied_bug10
},
6247 {"user_supplied_bug11", 1, (test_callback_fn
)user_supplied_bug11
},
6248 {"user_supplied_bug12", 1, (test_callback_fn
)user_supplied_bug12
},
6249 {"user_supplied_bug13", 1, (test_callback_fn
)user_supplied_bug13
},
6250 {"user_supplied_bug14", 1, (test_callback_fn
)user_supplied_bug14
},
6251 {"user_supplied_bug15", 1, (test_callback_fn
)user_supplied_bug15
},
6252 {"user_supplied_bug16", 1, (test_callback_fn
)user_supplied_bug16
},
6253 #if !defined(__sun) && !defined(__OpenBSD__)
6255 ** It seems to be something weird with the character sets..
6256 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6257 ** guess I need to find out how this is supposed to work.. Perhaps I need
6258 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6259 ** so just disable the code for now...).
6261 {"user_supplied_bug17", 1, (test_callback_fn
)user_supplied_bug17
},
6263 {"user_supplied_bug18", 1, (test_callback_fn
)user_supplied_bug18
},
6264 {"user_supplied_bug19", 1, (test_callback_fn
)user_supplied_bug19
},
6265 {"user_supplied_bug20", 1, (test_callback_fn
)user_supplied_bug20
},
6266 {"user_supplied_bug21", 1, (test_callback_fn
)user_supplied_bug21
},
6267 {"wrong_failure_counter_test", 1, (test_callback_fn
)wrong_failure_counter_test
},
6268 {0, 0, (test_callback_fn
)0}
6271 test_st replication_tests
[]= {
6272 {"set", 1, (test_callback_fn
)replication_set_test
},
6273 {"get", 0, (test_callback_fn
)replication_get_test
},
6274 {"mget", 0, (test_callback_fn
)replication_mget_test
},
6275 {"delete", 0, (test_callback_fn
)replication_delete_test
},
6276 {"rand_mget", 0, (test_callback_fn
)replication_randomize_mget_test
},
6277 {0, 0, (test_callback_fn
)0}
6281 * The following test suite is used to verify that we don't introduce
6282 * regression bugs. If you want more information about the bug / test,
6283 * you should look in the bug report at
6284 * http://bugs.launchpad.net/libmemcached
6286 test_st regression_tests
[]= {
6287 {"lp:434484", 1, (test_callback_fn
)regression_bug_434484
},
6288 {"lp:434843", 1, (test_callback_fn
)regression_bug_434843
},
6289 {"lp:434843-buffered", 1, (test_callback_fn
)regression_bug_434843_buffered
},
6290 {"lp:421108", 1, (test_callback_fn
)regression_bug_421108
},
6291 {"lp:442914", 1, (test_callback_fn
)regression_bug_442914
},
6292 {"lp:447342", 1, (test_callback_fn
)regression_bug_447342
},
6293 {"lp:463297", 1, (test_callback_fn
)regression_bug_463297
},
6294 {"lp:490486", 1, (test_callback_fn
)regression_bug_490486
},
6295 {"lp:583031", 1, (test_callback_fn
)regression_bug_583031
},
6296 {"lp:?", 1, (test_callback_fn
)regression_bug_
},
6297 {0, 0, (test_callback_fn
)0}
6300 test_st sasl_auth_tests
[]= {
6301 {"sasl_auth", 1, (test_callback_fn
)sasl_auth_test
},
6302 {0, 0, (test_callback_fn
)0}
6305 test_st ketama_compatibility
[]= {
6306 {"libmemcached", 1, (test_callback_fn
)ketama_compatibility_libmemcached
},
6307 {"spymemcached", 1, (test_callback_fn
)ketama_compatibility_spymemcached
},
6308 {0, 0, (test_callback_fn
)0}
6311 test_st generate_tests
[] ={
6312 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6313 {"generate_data", 1, (test_callback_fn
)generate_data
},
6314 {"get_read", 0, (test_callback_fn
)get_read
},
6315 {"delete_generate", 0, (test_callback_fn
)delete_generate
},
6316 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
6317 {"delete_buffer", 0, (test_callback_fn
)delete_buffer_generate
},
6318 {"generate_data", 1, (test_callback_fn
)generate_data
},
6319 {"mget_read", 0, (test_callback_fn
)mget_read
},
6320 {"mget_read_result", 0, (test_callback_fn
)mget_read_result
},
6321 {"mget_read_function", 0, (test_callback_fn
)mget_read_function
},
6322 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6323 {"generate_large_pairs", 1, (test_callback_fn
)generate_large_pairs
},
6324 {"generate_data", 1, (test_callback_fn
)generate_data
},
6325 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
6326 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6327 {0, 0, (test_callback_fn
)0}
6330 test_st consistent_tests
[] ={
6331 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6332 {"generate_data", 1, (test_callback_fn
)generate_data
},
6333 {"get_read", 0, (test_callback_fn
)get_read_count
},
6334 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6335 {0, 0, (test_callback_fn
)0}
6338 test_st consistent_weighted_tests
[] ={
6339 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
6340 {"generate_data", 1, (test_callback_fn
)generate_data_with_stats
},
6341 {"get_read", 0, (test_callback_fn
)get_read_count
},
6342 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
6343 {0, 0, (test_callback_fn
)0}
6346 test_st hsieh_availability
[] ={
6347 {"hsieh_avaibility_test", 0, (test_callback_fn
)hsieh_avaibility_test
},
6348 {0, 0, (test_callback_fn
)0}
6352 test_st hash_sanity
[] ={
6353 {"hash sanity", 0, (test_callback_fn
)hash_sanity_test
},
6354 {0, 0, (test_callback_fn
)0}
6358 test_st ketama_auto_eject_hosts
[] ={
6359 {"auto_eject_hosts", 1, (test_callback_fn
)auto_eject_hosts
},
6360 {"output_ketama_weighted_keys", 1, (test_callback_fn
)output_ketama_weighted_keys
},
6361 {0, 0, (test_callback_fn
)0}
6364 test_st hash_tests
[] ={
6365 {"one_at_a_time_run", 0, (test_callback_fn
)one_at_a_time_run
},
6366 {"md5", 0, (test_callback_fn
)md5_run
},
6367 {"crc", 0, (test_callback_fn
)crc_run
},
6368 {"fnv1_64", 0, (test_callback_fn
)fnv1_64_run
},
6369 {"fnv1a_64", 0, (test_callback_fn
)fnv1a_64_run
},
6370 {"fnv1_32", 0, (test_callback_fn
)fnv1_32_run
},
6371 {"fnv1a_32", 0, (test_callback_fn
)fnv1a_32_run
},
6372 {"hsieh", 0, (test_callback_fn
)hsieh_run
},
6373 {"murmur", 0, (test_callback_fn
)murmur_run
},
6374 {"jenkis", 0, (test_callback_fn
)jenkins_run
},
6375 {"memcached_get_hashkit", 0, (test_callback_fn
)memcached_get_hashkit_test
},
6376 {0, 0, (test_callback_fn
)0}
6379 test_st error_conditions
[] ={
6380 {"memcached_get_MEMCACHED_ERRNO", 0, (test_callback_fn
)memcached_get_MEMCACHED_ERRNO
},
6381 {"memcached_get_MEMCACHED_NOTFOUND", 0, (test_callback_fn
)memcached_get_MEMCACHED_NOTFOUND
},
6382 {"memcached_get_by_key_MEMCACHED_ERRNO", 0, (test_callback_fn
)memcached_get_by_key_MEMCACHED_ERRNO
},
6383 {"memcached_get_by_key_MEMCACHED_NOTFOUND", 0, (test_callback_fn
)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6384 {0, 0, (test_callback_fn
)0}
6387 collection_st collection
[] ={
6389 {"hash_sanity", 0, 0, hash_sanity
},
6391 {"hsieh_availability", 0, 0, hsieh_availability
},
6392 {"block", 0, 0, tests
},
6393 {"binary", (test_callback_fn
)pre_binary
, 0, tests
},
6394 {"nonblock", (test_callback_fn
)pre_nonblock
, 0, tests
},
6395 {"nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6396 {"settimer", (test_callback_fn
)pre_settimer
, 0, tests
},
6397 {"md5", (test_callback_fn
)pre_md5
, 0, tests
},
6398 {"crc", (test_callback_fn
)pre_crc
, 0, tests
},
6399 {"hsieh", (test_callback_fn
)pre_hsieh
, 0, tests
},
6400 {"jenkins", (test_callback_fn
)pre_jenkins
, 0, tests
},
6401 {"fnv1_64", (test_callback_fn
)pre_hash_fnv1_64
, 0, tests
},
6402 {"fnv1a_64", (test_callback_fn
)pre_hash_fnv1a_64
, 0, tests
},
6403 {"fnv1_32", (test_callback_fn
)pre_hash_fnv1_32
, 0, tests
},
6404 {"fnv1a_32", (test_callback_fn
)pre_hash_fnv1a_32
, 0, tests
},
6405 {"ketama", (test_callback_fn
)pre_behavior_ketama
, 0, tests
},
6406 {"ketama_auto_eject_hosts", (test_callback_fn
)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6407 {"unix_socket", (test_callback_fn
)pre_unix_socket
, 0, tests
},
6408 {"unix_socket_nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6409 {"poll_timeout", (test_callback_fn
)poll_timeout
, 0, tests
},
6410 {"gets", (test_callback_fn
)enable_cas
, 0, tests
},
6411 {"consistent_crc", (test_callback_fn
)enable_consistent_crc
, 0, tests
},
6412 {"consistent_hsieh", (test_callback_fn
)enable_consistent_hsieh
, 0, tests
},
6413 #ifdef MEMCACHED_ENABLE_DEPRECATED
6414 {"deprecated_memory_allocators", (test_callback_fn
)deprecated_set_memory_alloc
, 0, tests
},
6416 {"memory_allocators", (test_callback_fn
)set_memory_alloc
, 0, tests
},
6417 {"prefix", (test_callback_fn
)set_prefix
, 0, tests
},
6418 {"sasl_auth", (test_callback_fn
)pre_sasl
, 0, sasl_auth_tests
},
6419 {"sasl", (test_callback_fn
)pre_sasl
, 0, tests
},
6420 {"version_1_2_3", (test_callback_fn
)check_for_1_2_3
, 0, version_1_2_3
},
6421 {"string", 0, 0, string_tests
},
6422 {"result", 0, 0, result_tests
},
6423 {"async", (test_callback_fn
)pre_nonblock
, 0, async_tests
},
6424 {"async_binary", (test_callback_fn
)pre_nonblock_binary
, 0, async_tests
},
6425 {"user", 0, 0, user_tests
},
6426 {"generate", 0, 0, generate_tests
},
6427 {"generate_hsieh", (test_callback_fn
)pre_hsieh
, 0, generate_tests
},
6428 {"generate_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, generate_tests
},
6429 {"generate_hsieh_consistent", (test_callback_fn
)enable_consistent_hsieh
, 0, generate_tests
},
6430 {"generate_md5", (test_callback_fn
)pre_md5
, 0, generate_tests
},
6431 {"generate_murmur", (test_callback_fn
)pre_murmur
, 0, generate_tests
},
6432 {"generate_jenkins", (test_callback_fn
)pre_jenkins
, 0, generate_tests
},
6433 {"generate_nonblock", (test_callback_fn
)pre_nonblock
, 0, generate_tests
},
6435 {"generate_corked", (test_callback_fn
)pre_cork
, 0, generate_tests
},
6436 {"generate_corked_and_nonblock", (test_callback_fn
)pre_cork_and_nonblock
, 0, generate_tests
},
6437 {"consistent_not", 0, 0, consistent_tests
},
6438 {"consistent_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, consistent_tests
},
6439 {"consistent_ketama_weighted", (test_callback_fn
)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6440 {"ketama_compat", 0, 0, ketama_compatibility
},
6441 {"test_hashes", 0, 0, hash_tests
},
6442 {"replication", (test_callback_fn
)pre_replication
, 0, replication_tests
},
6443 {"replication_noblock", (test_callback_fn
)pre_replication_noblock
, 0, replication_tests
},
6444 {"regression", 0, 0, regression_tests
},
6445 {"behaviors", 0, 0, behavior_tests
},
6446 {"regression_binary_vs_block", (test_callback_fn
)key_setup
, (test_callback_fn
)key_teardown
, regression_binary_vs_block
},
6447 {"error_conditions", 0, 0, error_conditions
},
6451 #define SERVERS_TO_CREATE 5
6453 #include "libmemcached_world.h"
6455 void get_world(world_st
*world
)
6457 world
->collections
= collection
;
6459 world
->create
= (test_callback_create_fn
)world_create
;
6460 world
->destroy
= (test_callback_fn
)world_destroy
;
6462 world
->test
.startup
= (test_callback_fn
)world_test_startup
;
6463 world
->test
.flush
= (test_callback_fn
)world_flush
;
6464 world
->test
.pre_run
= (test_callback_fn
)world_pre_run
;
6465 world
->test
.post_run
= (test_callback_fn
)world_post_run
;
6466 world
->test
.on_error
= (test_callback_error_fn
)world_on_error
;
6468 world
->collection
.startup
= (test_callback_fn
)world_container_startup
;
6469 world
->collection
.shutdown
= (test_callback_fn
)world_container_shutdown
;
6471 world
->runner
= &defualt_libmemcached_runner
;