1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 #include <libtest/test.hpp>
45 #include <libmemcached-1.0/memcached.h>
46 #include <libmemcached/is.h>
47 #include <libmemcached/server_instance.h>
49 #include <libhashkit-1.0/hashkit.h>
55 #include <semaphore.h>
59 #include <sys/types.h>
64 #include <libtest/server.h>
66 #include "clients/generator.h"
67 #include "clients/execute.h"
69 #define SMALL_STRING_LEN 1024
71 #include <libtest/test.hpp>
73 #include "tests/basic.h"
74 #include "tests/debug.h"
75 #include "tests/deprecated.h"
76 #include "tests/error_conditions.h"
77 #include "tests/exist.h"
78 #include "tests/ketama.h"
79 #include "tests/namespace.h"
80 #include "tests/parser.h"
81 #include "tests/touch.h"
82 #include "tests/callbacks.h"
83 #include "tests/pool.h"
84 #include "tests/print.h"
85 #include "tests/replication.h"
86 #include "tests/server_add.h"
87 #include "tests/virtual_buckets.h"
89 using namespace libtest
;
91 #include <libmemcached/util.h>
93 #include "hash_results.h"
95 #define GLOBAL_COUNT 10000
96 #define GLOBAL2_COUNT 100
97 #define SERVERS_TO_CREATE 5
98 static uint32_t global_count
;
100 static pairs_st
*global_pairs
;
101 static const char *global_keys
[GLOBAL_COUNT
];
102 static size_t global_keys_length
[GLOBAL_COUNT
];
105 @note This should be testing to see if the server really supports the binary protocol.
107 static test_return_t
pre_binary(memcached_st
*memc
)
109 memcached_return_t rc
= MEMCACHED_FAILURE
;
111 if (libmemcached_util_version_check(memc
, 1, 4, 4))
113 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
114 test_compare(MEMCACHED_SUCCESS
, rc
);
115 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
118 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
122 static test_return_t
init_test(memcached_st
*not_used
)
127 (void)memcached_create(&memc
);
128 memcached_free(&memc
);
133 #define TEST_PORT_COUNT 7
134 in_port_t test_ports
[TEST_PORT_COUNT
];
136 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
137 const memcached_server_st
*server
,
141 size_t bigger
= *((size_t *)(context
));
143 assert(bigger
<= memcached_server_port(server
));
144 *((size_t *)(context
))= memcached_server_port(server
);
146 return MEMCACHED_SUCCESS
;
149 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
150 const memcached_server_st
*instance
,
154 FILE *stream
= (FILE *)context
;
157 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
158 memcached_server_name(instance
),
159 memcached_server_port(instance
),
160 instance
->major_version
,
161 instance
->minor_version
,
162 instance
->micro_version
);
164 return MEMCACHED_SUCCESS
;
167 static test_return_t
server_sort_test(memcached_st
*ptr
)
169 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
171 memcached_return_t rc
;
172 memcached_server_fn callbacks
[1];
173 memcached_st
*local_memc
;
176 local_memc
= memcached_create(NULL
);
177 test_true(local_memc
);
178 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
180 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
182 test_ports
[x
]= (in_port_t
)random() % 64000;
183 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
184 test_compare(memcached_server_count(local_memc
), x
+1);
186 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
188 test_compare(MEMCACHED_SUCCESS
, rc
);
191 callbacks
[0]= server_display_function
;
192 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
195 memcached_free(local_memc
);
200 static test_return_t
server_sort2_test(memcached_st
*ptr
)
202 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
203 memcached_server_fn callbacks
[1];
204 memcached_st
*local_memc
;
205 memcached_server_instance_st instance
;
208 local_memc
= memcached_create(NULL
);
209 test_true(local_memc
);
210 test_compare(MEMCACHED_SUCCESS
,
211 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
213 test_compare(MEMCACHED_SUCCESS
,
214 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
215 instance
= memcached_server_instance_by_position(local_memc
, 0);
216 test_compare(in_port_t(43043), memcached_server_port(instance
));
218 test_compare(MEMCACHED_SUCCESS
,
219 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
221 instance
= memcached_server_instance_by_position(local_memc
, 0);
222 test_compare(in_port_t(43042), memcached_server_port(instance
));
224 instance
= memcached_server_instance_by_position(local_memc
, 1);
225 test_compare(in_port_t(43043), memcached_server_port(instance
));
227 callbacks
[0]= server_display_function
;
228 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
231 memcached_free(local_memc
);
236 static test_return_t
memcached_server_remove_test(memcached_st
*)
238 const char *server_string
= "--server=localhost:4444 --server=localhost:4445 --server=localhost:4446 --server=localhost:4447 --server=localhost --server=memcache1.memcache.bk.sapo.pt:11211 --server=memcache1.memcache.bk.sapo.pt:11212 --server=memcache1.memcache.bk.sapo.pt:11213 --server=memcache1.memcache.bk.sapo.pt:11214 --server=memcache2.memcache.bk.sapo.pt:11211 --server=memcache2.memcache.bk.sapo.pt:11212 --server=memcache2.memcache.bk.sapo.pt:11213 --server=memcache2.memcache.bk.sapo.pt:11214";
241 test_compare(MEMCACHED_SUCCESS
,
242 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
243 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
246 memcached_server_fn callbacks
[1];
247 callbacks
[0]= server_print_callback
;
248 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
250 memcached_free(memc
);
255 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
256 const memcached_server_st
*server
,
260 uint32_t x
= *((uint32_t *)(context
));
262 if (! (test_ports
[x
] == server
->port
))
264 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
265 return MEMCACHED_FAILURE
;
268 *((uint32_t *)(context
))= ++x
;
270 return MEMCACHED_SUCCESS
;
273 static test_return_t
server_unsort_test(memcached_st
*ptr
)
275 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
276 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
277 memcached_server_fn callbacks
[1];
278 memcached_st
*local_memc
;
281 local_memc
= memcached_create(NULL
);
282 test_true(local_memc
);
284 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
286 test_ports
[x
]= (in_port_t
)(random() % 64000);
287 test_compare(MEMCACHED_SUCCESS
,
288 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
289 test_compare(memcached_server_count(local_memc
), x
+1);
291 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
295 callbacks
[0]= server_display_unsort_function
;
296 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
298 /* Now we sort old data! */
299 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
300 callbacks
[0]= server_display_function
;
301 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
304 memcached_free(local_memc
);
309 static test_return_t
allocation_test(memcached_st
*not_used
)
313 memc
= memcached_create(NULL
);
315 memcached_free(memc
);
320 static test_return_t
clone_test(memcached_st
*memc
)
324 memcached_st
*memc_clone
;
325 memc_clone
= memcached_clone(NULL
, NULL
);
326 test_true(memc_clone
);
327 memcached_free(memc_clone
);
330 /* Can we init from null? */
332 memcached_st
*memc_clone
;
333 memc_clone
= memcached_clone(NULL
, memc
);
334 test_true(memc_clone
);
337 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
338 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
339 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
340 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
343 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
344 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
345 test_true(memc_clone
->distribution
== memc
->distribution
);
346 { // Test all of the flags
347 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
348 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
349 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
350 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
351 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
352 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
353 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
354 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
355 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
356 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
357 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
358 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
359 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
361 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
362 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
363 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
364 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
365 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
366 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
367 test_true(memc_clone
->on_clone
== memc
->on_clone
);
368 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
369 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
370 test_true(memc_clone
->recv_size
== memc
->recv_size
);
371 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
372 test_true(memc_clone
->send_size
== memc
->send_size
);
373 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
374 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
375 test_true(memc_clone
->user_data
== memc
->user_data
);
377 memcached_free(memc_clone
);
380 /* Can we init from struct? */
382 memcached_st declared_clone
;
383 memcached_st
*memc_clone
;
384 memset(&declared_clone
, 0 , sizeof(memcached_st
));
385 memc_clone
= memcached_clone(&declared_clone
, NULL
);
386 test_true(memc_clone
);
387 memcached_free(memc_clone
);
390 /* Can we init from struct? */
392 memcached_st declared_clone
;
393 memcached_st
*memc_clone
;
394 memset(&declared_clone
, 0 , sizeof(memcached_st
));
395 memc_clone
= memcached_clone(&declared_clone
, memc
);
396 test_true(memc_clone
);
397 memcached_free(memc_clone
);
403 static test_return_t
userdata_test(memcached_st
*memc
)
406 test_false(memcached_set_user_data(memc
, foo
));
407 test_true(memcached_get_user_data(memc
) == foo
);
408 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
413 static test_return_t
connection_test(memcached_st
*memc
)
415 test_compare(MEMCACHED_SUCCESS
,
416 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
421 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
423 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
425 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
427 test_compare(36, int(MEMCACHED_BEHAVIOR_MAX
));
432 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
434 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
436 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
438 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
443 static test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
445 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
446 982370485U, 1263635348U, 4242906218U, 3829656100U,
447 1891735253U, 334139633U, 2257084983U, 3088286104U,
448 13199785U, 2542027183U, 1097051614U, 199566778U,
449 2748246961U, 2465192557U, 1664094137U, 2405439045U,
450 1842224848U, 692413798U, 3479807801U, 919913813U,
451 4269430871U, 610793021U, 527273862U, 1437122909U,
452 2300930706U, 2943759320U, 674306647U, 2400528935U,
453 54481931U, 4186304426U, 1741088401U, 2979625118U,
454 4159057246U, 3425930182U, 2593724503U, 1868899624U,
455 1769812374U, 2302537950U, 1110330676U, 3365377466U,
456 1336171666U, 3021258493U, 2334992265U, 3861994737U,
459 // You have updated the memcache_error messages but not updated docs/tests.
460 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
463 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
464 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
465 MEMCACHED_HASH_JENKINS
);
466 if (values
[rc
] != hash_val
)
468 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
469 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
471 test_compare(values
[rc
], hash_val
);
473 test_compare(48, int(MEMCACHED_MAXIMUM_RETURN
));
478 static test_return_t
set_test(memcached_st
*memc
)
480 memcached_return_t rc
= memcached_set(memc
,
481 test_literal_param("foo"),
482 test_literal_param("when we sanitize"),
483 time_t(0), (uint32_t)0);
484 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
489 static test_return_t
append_test(memcached_st
*memc
)
491 memcached_return_t rc
;
492 const char *key
= "fig";
493 const char *in_value
= "we";
494 char *out_value
= NULL
;
498 rc
= memcached_flush(memc
, 0);
499 test_compare(MEMCACHED_SUCCESS
, rc
);
501 rc
= memcached_set(memc
, key
, strlen(key
),
502 in_value
, strlen(in_value
),
503 (time_t)0, (uint32_t)0);
504 test_compare(MEMCACHED_SUCCESS
, rc
);
506 rc
= memcached_append(memc
, key
, strlen(key
),
507 " the", strlen(" the"),
508 (time_t)0, (uint32_t)0);
509 test_compare(MEMCACHED_SUCCESS
, rc
);
511 rc
= memcached_append(memc
, key
, strlen(key
),
512 " people", strlen(" people"),
513 (time_t)0, (uint32_t)0);
514 test_compare(MEMCACHED_SUCCESS
, rc
);
516 out_value
= memcached_get(memc
, key
, strlen(key
),
517 &value_length
, &flags
, &rc
);
518 test_memcmp(out_value
, "we the people", strlen("we the people"));
519 test_compare(strlen("we the people"), value_length
);
520 test_compare(MEMCACHED_SUCCESS
, rc
);
526 static test_return_t
append_binary_test(memcached_st
*memc
)
528 memcached_return_t rc
;
529 const char *key
= "numbers";
530 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
536 rc
= memcached_flush(memc
, 0);
537 test_compare(MEMCACHED_SUCCESS
, rc
);
539 rc
= memcached_set(memc
,
542 (time_t)0, (uint32_t)0);
543 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
545 for (x
= 0; store_list
[x
] ; x
++)
547 rc
= memcached_append(memc
,
549 (char *)&store_list
[x
], sizeof(uint32_t),
550 (time_t)0, (uint32_t)0);
551 test_compare(MEMCACHED_SUCCESS
, rc
);
554 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
555 &value_length
, &flags
, &rc
);
556 test_compare(value_length
, sizeof(uint32_t) * x
);
557 test_compare(MEMCACHED_SUCCESS
, rc
);
559 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
561 test_compare(*ptr
, store_list
[x
- counter
]);
569 static test_return_t
cas2_test(memcached_st
*memc
)
571 memcached_return_t rc
;
572 const char *keys
[]= {"fudge", "son", "food"};
573 size_t key_length
[]= {5, 3, 4};
574 const char *value
= "we the people";
575 size_t value_length
= strlen("we the people");
576 memcached_result_st results_obj
;
577 memcached_result_st
*results
;
580 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
582 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
584 for (uint32_t x
= 0; x
< 3; x
++)
586 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
587 keys
[x
], key_length
[x
],
588 (time_t)50, (uint32_t)9);
589 test_compare(MEMCACHED_SUCCESS
, rc
);
592 test_compare(MEMCACHED_SUCCESS
,
593 memcached_mget(memc
, keys
, key_length
, 3));
595 results
= memcached_result_create(memc
, &results_obj
);
598 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
600 test_true(results
->item_cas
);
601 test_compare(MEMCACHED_SUCCESS
, rc
);
602 test_true(memcached_result_cas(results
));
604 test_memcmp(value
, "we the people", strlen("we the people"));
605 test_compare(strlen("we the people"), value_length
);
606 test_compare(MEMCACHED_SUCCESS
, rc
);
608 memcached_result_free(&results_obj
);
613 static test_return_t
cas_test(memcached_st
*memc
)
615 memcached_return_t rc
;
616 const char *key
= "fun";
617 size_t key_length
= strlen(key
);
618 const char *value
= "we the people";
619 const char* keys
[2] = { key
, NULL
};
620 size_t keylengths
[2] = { strlen(key
), 0 };
621 size_t value_length
= strlen(value
);
622 const char *value2
= "change the value";
623 size_t value2_length
= strlen(value2
);
625 memcached_result_st results_obj
;
626 memcached_result_st
*results
;
629 rc
= memcached_flush(memc
, 0);
630 test_compare(MEMCACHED_SUCCESS
, rc
);
632 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
634 rc
= memcached_set(memc
, key
, strlen(key
),
635 value
, strlen(value
),
636 (time_t)0, (uint32_t)0);
637 test_compare(MEMCACHED_SUCCESS
, rc
);
639 test_compare(MEMCACHED_SUCCESS
,
640 memcached_mget(memc
, keys
, keylengths
, 1));
642 results
= memcached_result_create(memc
, &results_obj
);
645 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
647 test_compare(MEMCACHED_SUCCESS
, rc
);
648 test_true(memcached_result_cas(results
));
649 test_memcmp(value
, memcached_result_value(results
), value_length
);
650 test_compare(strlen(memcached_result_value(results
)), value_length
);
651 test_compare(MEMCACHED_SUCCESS
, rc
);
652 uint64_t cas
= memcached_result_cas(results
);
655 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
656 test_true(rc
== MEMCACHED_END
);
657 test_true(results
== NULL
);
660 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
661 test_compare(MEMCACHED_SUCCESS
, rc
);
664 * The item will have a new cas value, so try to set it again with the old
665 * value. This should fail!
667 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
668 test_compare(MEMCACHED_DATA_EXISTS
, rc
);
670 memcached_result_free(&results_obj
);
675 static test_return_t
prepend_test(memcached_st
*memc
)
677 memcached_return_t rc
;
678 const char *key
= "fig";
679 const char *value
= "people";
680 char *out_value
= NULL
;
684 rc
= memcached_flush(memc
, 0);
685 test_compare(MEMCACHED_SUCCESS
, rc
);
687 rc
= memcached_set(memc
, key
, strlen(key
),
688 value
, strlen(value
),
689 (time_t)0, (uint32_t)0);
690 test_compare(MEMCACHED_SUCCESS
, rc
);
692 rc
= memcached_prepend(memc
, key
, strlen(key
),
693 "the ", strlen("the "),
694 (time_t)0, (uint32_t)0);
695 test_compare(MEMCACHED_SUCCESS
, rc
);
697 rc
= memcached_prepend(memc
, key
, strlen(key
),
698 "we ", strlen("we "),
699 (time_t)0, (uint32_t)0);
700 test_compare(MEMCACHED_SUCCESS
, rc
);
702 out_value
= memcached_get(memc
, key
, strlen(key
),
703 &value_length
, &flags
, &rc
);
704 test_memcmp(out_value
, "we the people", strlen("we the people"));
705 test_compare(strlen("we the people"), value_length
);
706 test_compare(MEMCACHED_SUCCESS
, rc
);
713 Set the value, then quit to make sure it is flushed.
714 Come back in and test that add fails.
716 static test_return_t
add_test(memcached_st
*memc
)
718 memcached_return_t rc
;
719 const char *key
= "foo";
720 const char *value
= "when we sanitize";
721 unsigned long long setting_value
;
723 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
725 rc
= memcached_set(memc
, key
, strlen(key
),
726 value
, strlen(value
),
727 (time_t)0, (uint32_t)0);
728 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
729 memcached_quit(memc
);
730 rc
= memcached_add(memc
, key
, strlen(key
),
731 value
, strlen(value
),
732 (time_t)0, (uint32_t)0);
734 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
737 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
741 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
748 ** There was a problem of leaking filedescriptors in the initial release
749 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
750 ** systems it seems that the kernel is slow on reclaiming the resources
751 ** because the connects starts to time out (the test doesn't do much
752 ** anyway, so just loop 10 iterations)
754 static test_return_t
add_wrapper(memcached_st
*memc
)
756 unsigned int max
= 10000;
764 for (uint32_t x
= 0; x
< max
; x
++)
770 static test_return_t
replace_test(memcached_st
*memc
)
772 memcached_return_t rc
;
773 const char *key
= "foo";
774 const char *value
= "when we sanitize";
775 const char *original
= "first we insert some data";
777 rc
= memcached_set(memc
, key
, strlen(key
),
778 original
, strlen(original
),
779 (time_t)0, (uint32_t)0);
780 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
782 test_compare(MEMCACHED_SUCCESS
,
783 memcached_replace(memc
, key
, strlen(key
),
784 value
, strlen(value
),
785 (time_t)0, (uint32_t)0));
790 static test_return_t
delete_test(memcached_st
*memc
)
792 memcached_return_t rc
;
793 const char *key
= "foo";
794 const char *value
= "when we sanitize";
796 rc
= memcached_set(memc
, key
, strlen(key
),
797 value
, strlen(value
),
798 (time_t)0, (uint32_t)0);
799 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
801 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
802 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
807 static test_return_t
flush_test(memcached_st
*memc
)
809 uint64_t query_id
= memcached_query_id(memc
);
810 test_compare(MEMCACHED_SUCCESS
,
811 memcached_flush(memc
, 0));
812 test_compare(query_id
+1, memcached_query_id(memc
));
817 static memcached_return_t
server_function(const memcached_st
*ptr
,
818 const memcached_server_st
*server
,
821 (void)ptr
; (void)server
; (void)context
;
824 return MEMCACHED_SUCCESS
;
827 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
830 strncpy(context
, "foo bad", sizeof(context
));
831 memcached_server_fn callbacks
[1];
833 callbacks
[0]= server_function
;
834 memcached_server_cursor(memc
, callbacks
, context
, 1);
838 static test_return_t
bad_key_test(memcached_st
*memc
)
840 memcached_return_t rc
;
841 const char *key
= "foo bad";
843 memcached_st
*memc_clone
;
845 uint64_t query_id
= memcached_query_id(memc
);
847 // Just skip if we are in binary mode.
848 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
850 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
852 memc_clone
= memcached_clone(NULL
, memc
);
853 test_true(memc_clone
);
855 query_id
= memcached_query_id(memc_clone
);
856 test_compare(MEMCACHED_SUCCESS
,
857 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
858 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
860 /* All keys are valid in the binary protocol (except for length) */
861 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
863 uint64_t before_query_id
= memcached_query_id(memc_clone
);
865 size_t string_length
;
866 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
867 &string_length
, &flags
, &rc
);
868 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
869 test_zero(string_length
);
872 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
874 query_id
= memcached_query_id(memc_clone
);
875 test_compare(MEMCACHED_SUCCESS
,
876 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
877 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
879 size_t string_length
;
880 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
881 &string_length
, &flags
, &rc
);
882 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
883 test_zero(string_length
);
887 /* Test multi key for bad keys */
888 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
889 size_t key_lengths
[] = { 7, 7, 7 };
890 query_id
= memcached_query_id(memc_clone
);
891 test_compare(MEMCACHED_SUCCESS
,
892 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
893 test_compare(query_id
, memcached_query_id(memc_clone
));
895 query_id
= memcached_query_id(memc_clone
);
896 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
897 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
898 test_compare(query_id
+1, memcached_query_id(memc_clone
));
900 query_id
= memcached_query_id(memc_clone
);
901 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
902 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
903 test_compare(query_id
+1, memcached_query_id(memc_clone
));
905 /* The following test should be moved to the end of this function when the
906 memcached server is updated to allow max size length of the keys in the
909 test_compare(MEMCACHED_SUCCESS
,
910 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
912 std::vector
<char> longkey
;
913 longkey
.reserve(MEMCACHED_MAX_KEY
);
914 longkey
.insert(longkey
.end(), MEMCACHED_MAX_KEY
, 'a');
915 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
917 size_t string_length
;
919 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
920 test_compare(MEMCACHED_NOTFOUND
, rc
);
921 test_zero(string_length
);
923 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
924 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
925 test_zero(string_length
);
929 /* Make sure zero length keys are marked as bad */
931 test_compare(MEMCACHED_SUCCESS
,
932 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
933 size_t string_length
;
934 char *string
= memcached_get(memc_clone
, key
, 0,
935 &string_length
, &flags
, &rc
);
936 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
937 test_zero(string_length
);
941 memcached_free(memc_clone
);
946 #define READ_THROUGH_VALUE "set for me"
947 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
950 memcached_result_st
*result
)
952 (void)memc
;(void)key
;(void)key_length
;
953 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
956 #ifndef __INTEL_COMPILER
957 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
960 static test_return_t
read_through(memcached_st
*memc
)
962 memcached_return_t rc
;
963 const char *key
= "foo";
965 size_t string_length
;
967 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
969 string
= memcached_get(memc
, key
, strlen(key
),
970 &string_length
, &flags
, &rc
);
972 test_compare(MEMCACHED_NOTFOUND
, rc
);
973 test_false(string_length
);
976 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
);
977 test_compare(MEMCACHED_SUCCESS
, rc
);
979 string
= memcached_get(memc
, key
, strlen(key
),
980 &string_length
, &flags
, &rc
);
982 test_compare(MEMCACHED_SUCCESS
, rc
);
983 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
984 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
985 test_strcmp(READ_THROUGH_VALUE
, string
);
988 string
= memcached_get(memc
, key
, strlen(key
),
989 &string_length
, &flags
, &rc
);
991 test_compare(MEMCACHED_SUCCESS
, rc
);
993 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
994 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
995 test_strcmp(READ_THROUGH_VALUE
, string
);
1001 static test_return_t
get_test(memcached_st
*memc
)
1003 memcached_return_t rc
;
1004 const char *key
= "foo";
1006 size_t string_length
;
1009 uint64_t query_id
= memcached_query_id(memc
);
1010 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
1011 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
1012 test_compare(query_id
+1, memcached_query_id(memc
));
1014 string
= memcached_get(memc
, key
, strlen(key
),
1015 &string_length
, &flags
, &rc
);
1017 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1018 test_false(string_length
);
1021 return TEST_SUCCESS
;
1024 static test_return_t
get_test2(memcached_st
*memc
)
1026 const char *key
= "foo";
1027 const char *value
= "when we sanitize";
1029 uint64_t query_id
= memcached_query_id(memc
);
1030 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1031 value
, strlen(value
),
1032 (time_t)0, (uint32_t)0);
1033 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1034 test_compare(query_id
+1, memcached_query_id(memc
));
1036 query_id
= memcached_query_id(memc
);
1037 test_true(query_id
);
1040 size_t string_length
;
1041 char *string
= memcached_get(memc
, key
, strlen(key
),
1042 &string_length
, &flags
, &rc
);
1043 test_compare(query_id
+1, memcached_query_id(memc
));
1045 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1046 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1048 test_compare(strlen(value
), string_length
);
1049 test_memcmp(string
, value
, string_length
);
1053 return TEST_SUCCESS
;
1056 static test_return_t
set_test2(memcached_st
*memc
)
1058 for (uint32_t x
= 0; x
< 10; x
++)
1060 memcached_return_t rc
= memcached_set(memc
,
1061 test_literal_param("foo"),
1062 test_literal_param("train in the brain"),
1063 time_t(0), uint32_t(0));
1064 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1067 return TEST_SUCCESS
;
1070 static test_return_t
set_test3(memcached_st
*memc
)
1072 size_t value_length
= 8191;
1074 std::vector
<char> value
;
1075 value
.reserve(value_length
);
1076 for (uint32_t x
= 0; x
< value_length
; x
++)
1078 value
.push_back(char(x
% 127));
1081 /* The dump test relies on there being at least 32 items in memcached */
1082 for (uint32_t x
= 0; x
< 32; x
++)
1086 snprintf(key
, sizeof(key
), "foo%u", x
);
1088 uint64_t query_id
= memcached_query_id(memc
);
1089 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1090 &value
[0], value
.size(),
1091 (time_t)0, (uint32_t)0);
1092 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1093 test_compare(query_id
+1, memcached_query_id(memc
));
1096 return TEST_SUCCESS
;
1099 static test_return_t
get_test3(memcached_st
*memc
)
1101 const char *key
= "foo";
1102 size_t value_length
= 8191;
1104 std::vector
<char> value
;
1105 value
.reserve(value_length
);
1106 for (uint32_t x
= 0; x
< value_length
; x
++)
1108 value
.push_back(char(x
% 127));
1111 memcached_return_t rc
;
1112 rc
= memcached_set(memc
, key
, strlen(key
),
1113 &value
[0], value
.size(),
1114 (time_t)0, (uint32_t)0);
1115 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1117 size_t string_length
;
1119 char *string
= memcached_get(memc
, key
, strlen(key
),
1120 &string_length
, &flags
, &rc
);
1122 test_compare(MEMCACHED_SUCCESS
, rc
);
1124 test_compare(string_length
, value_length
);
1125 test_memcmp(string
, &value
[0], string_length
);
1129 return TEST_SUCCESS
;
1132 static test_return_t
get_test4(memcached_st
*memc
)
1134 const char *key
= "foo";
1135 size_t value_length
= 8191;
1137 std::vector
<char> value
;
1138 value
.reserve(value_length
);
1139 for (uint32_t x
= 0; x
< value_length
; x
++)
1141 value
.push_back(char(x
% 127));
1144 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1145 &value
[0], value
.size(),
1146 (time_t)0, (uint32_t)0);
1147 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1149 for (uint32_t x
= 0; x
< 10; x
++)
1152 size_t string_length
;
1153 char *string
= memcached_get(memc
, key
, strlen(key
),
1154 &string_length
, &flags
, &rc
);
1156 test_compare(MEMCACHED_SUCCESS
, rc
);
1158 test_compare(string_length
, value_length
);
1159 test_memcmp(string
, &value
[0], string_length
);
1163 return TEST_SUCCESS
;
1167 * This test verifies that memcached_read_one_response doesn't try to
1168 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1169 * responses before you execute a storage command.
1171 static test_return_t
get_test5(memcached_st
*memc
)
1174 ** Request the same key twice, to ensure that we hash to the same server
1175 ** (so that we have multiple response values queued up) ;-)
1177 const char *keys
[]= { "key", "key" };
1178 size_t lengths
[]= { 3, 3 };
1182 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1183 keys
[0], lengths
[0], 0, 0);
1184 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1186 memcached_result_st results_obj
;
1187 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1190 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1193 memcached_result_free(&results_obj
);
1195 /* Don't read out the second result, but issue a set instead.. */
1196 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1198 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1199 &rlen
, &flags
, &rc
);
1201 test_compare(MEMCACHED_NOTFOUND
, rc
);
1202 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1204 test_compare(MEMCACHED_SUCCESS
, rc
);
1207 return TEST_SUCCESS
;
1210 static test_return_t
mget_end(memcached_st
*memc
)
1212 const char *keys
[]= { "foo", "foo2" };
1213 size_t lengths
[]= { 3, 4 };
1214 const char *values
[]= { "fjord", "41" };
1216 memcached_return_t rc
;
1219 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1221 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[x
], lengths
[x
], values
[x
], strlen(values
[x
]), (time_t)0, (uint32_t)0));
1225 size_t string_length
;
1228 // retrieve both via mget
1229 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1231 char key
[MEMCACHED_MAX_KEY
];
1234 // this should get both
1235 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1237 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1239 test_compare(MEMCACHED_SUCCESS
, rc
);
1241 if (key_length
== 4)
1246 test_compare(string_length
, strlen(values
[val
]));
1247 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1251 // this should indicate end
1252 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1253 test_compare(MEMCACHED_END
, rc
);
1257 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1258 test_compare(MEMCACHED_SUCCESS
, rc
);
1260 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1261 test_compare(key_length
, lengths
[0]);
1262 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1263 test_compare(string_length
, strlen(values
[0]));
1264 test_true(strncmp(values
[0], string
, string_length
) == 0);
1265 test_compare(MEMCACHED_SUCCESS
, rc
);
1268 // this should indicate end
1269 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1270 test_compare(MEMCACHED_END
, rc
);
1273 return TEST_SUCCESS
;
1276 /* Do not copy the style of this code, I just access hosts to testthis function */
1277 static test_return_t
stats_servername_test(memcached_st
*memc
)
1279 memcached_stat_st memc_stat
;
1280 memcached_server_instance_st instance
=
1281 memcached_server_instance_by_position(memc
, 0);
1283 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1285 return TEST_SKIPPED
;
1288 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1289 memcached_server_name(instance
),
1290 memcached_server_port(instance
)));
1292 return TEST_SUCCESS
;
1295 static test_return_t
increment_test(memcached_st
*memc
)
1297 uint64_t new_number
;
1299 test_compare(MEMCACHED_SUCCESS
,
1301 test_literal_param("number"),
1302 test_literal_param("0"),
1303 (time_t)0, (uint32_t)0));
1305 test_compare(MEMCACHED_SUCCESS
,
1306 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1307 test_compare(uint64_t(1), new_number
);
1309 test_compare(MEMCACHED_SUCCESS
,
1310 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1311 test_compare(uint64_t(2), new_number
);
1313 return TEST_SUCCESS
;
1316 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1318 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1320 uint64_t new_number
;
1321 uint64_t initial
= 0;
1323 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1325 test_compare(MEMCACHED_SUCCESS
,
1326 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1327 test_compare(new_number
, initial
);
1329 test_compare(MEMCACHED_SUCCESS
,
1330 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1331 test_compare(new_number
, (initial
+1));
1333 return TEST_SUCCESS
;
1336 static test_return_t
decrement_test(memcached_st
*memc
)
1338 uint64_t new_number
;
1339 memcached_return_t rc
;
1340 const char *value
= "3";
1342 rc
= memcached_set(memc
,
1343 test_literal_param("number"),
1344 value
, strlen(value
),
1345 (time_t)0, (uint32_t)0);
1346 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1348 test_compare(MEMCACHED_SUCCESS
,
1349 memcached_decrement(memc
,
1350 test_literal_param("number"),
1352 test_compare(uint64_t(2), new_number
);
1354 test_compare(MEMCACHED_SUCCESS
,
1355 memcached_decrement(memc
,
1356 test_literal_param("number"),
1358 test_compare(uint64_t(1), new_number
);
1360 return TEST_SUCCESS
;
1363 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1365 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1367 uint64_t new_number
;
1368 uint64_t initial
= 3;
1370 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1372 test_compare(MEMCACHED_SUCCESS
,
1373 memcached_decrement_with_initial(memc
,
1374 test_literal_param("number"),
1375 1, initial
, 0, &new_number
));
1376 test_compare(new_number
, initial
);
1378 test_compare(MEMCACHED_SUCCESS
,
1379 memcached_decrement_with_initial(memc
,
1380 test_literal_param("number"),
1381 1, initial
, 0, &new_number
));
1382 test_compare(new_number
, (initial
- 1));
1384 return TEST_SUCCESS
;
1387 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1389 uint64_t new_number
;
1390 memcached_return_t rc
;
1391 const char *master_key
= "foo";
1392 const char *key
= "number";
1393 const char *value
= "0";
1395 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1397 value
, strlen(value
),
1398 (time_t)0, (uint32_t)0);
1399 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1401 test_compare(MEMCACHED_SUCCESS
,
1402 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1403 test_compare(uint64_t(1), new_number
);
1405 test_compare(MEMCACHED_SUCCESS
,
1406 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1407 test_compare(uint64_t(2), new_number
);
1409 return TEST_SUCCESS
;
1412 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1414 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1416 uint64_t new_number
;
1417 memcached_return_t rc
;
1418 const char *master_key
= "foo";
1419 const char *key
= "number";
1420 uint64_t initial
= 0;
1422 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1424 1, initial
, 0, &new_number
);
1425 test_compare(MEMCACHED_SUCCESS
, rc
);
1426 test_compare(new_number
, initial
);
1428 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1430 1, initial
, 0, &new_number
);
1431 test_compare(MEMCACHED_SUCCESS
, rc
);
1432 test_compare(new_number
, (initial
+1));
1434 return TEST_SUCCESS
;
1437 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1439 uint64_t new_number
;
1440 memcached_return_t rc
;
1441 const char *value
= "3";
1443 rc
= memcached_set_by_key(memc
,
1444 test_literal_param("foo"),
1445 test_literal_param("number"),
1446 value
, strlen(value
),
1447 (time_t)0, (uint32_t)0);
1448 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1450 test_compare(MEMCACHED_SUCCESS
,
1451 memcached_decrement_by_key(memc
,
1452 test_literal_param("foo"),
1453 test_literal_param("number"),
1455 test_compare(uint64_t(2), new_number
);
1457 test_compare(MEMCACHED_SUCCESS
,
1458 memcached_decrement_by_key(memc
,
1459 test_literal_param("foo"),
1460 test_literal_param("number"),
1462 test_compare(uint64_t(1), new_number
);
1464 return TEST_SUCCESS
;
1467 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1469 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1471 uint64_t new_number
;
1472 uint64_t initial
= 3;
1474 test_compare(MEMCACHED_SUCCESS
,
1475 memcached_decrement_with_initial_by_key(memc
,
1476 test_literal_param("foo"),
1477 test_literal_param("number"),
1478 1, initial
, 0, &new_number
));
1479 test_compare(new_number
, initial
);
1481 test_compare(MEMCACHED_SUCCESS
,
1482 memcached_decrement_with_initial_by_key(memc
,
1483 test_literal_param("foo"),
1484 test_literal_param("number"),
1485 1, initial
, 0, &new_number
));
1486 test_compare(new_number
, (initial
- 1));
1488 return TEST_SUCCESS
;
1490 static test_return_t
binary_increment_with_prefix_test(memcached_st
*orig_memc
)
1492 memcached_st
*memc
= memcached_clone(NULL
, orig_memc
);
1494 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1496 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1498 memcached_return_t rc
;
1499 rc
= memcached_set(memc
,
1500 test_literal_param("number"),
1501 test_literal_param("0"),
1502 (time_t)0, (uint32_t)0);
1503 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1505 uint64_t new_number
;
1506 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1507 test_literal_param("number"),
1509 test_compare(uint64_t(1), new_number
);
1511 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1512 test_literal_param("number"),
1514 test_compare(uint64_t(2), new_number
);
1515 memcached_free(memc
);
1517 return TEST_SUCCESS
;
1520 static test_return_t
quit_test(memcached_st
*memc
)
1522 memcached_return_t rc
;
1523 const char *key
= "fudge";
1524 const char *value
= "sanford and sun";
1526 rc
= memcached_set(memc
, key
, strlen(key
),
1527 value
, strlen(value
),
1528 (time_t)10, (uint32_t)3);
1529 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1530 memcached_quit(memc
);
1532 rc
= memcached_set(memc
, key
, strlen(key
),
1533 value
, strlen(value
),
1534 (time_t)50, (uint32_t)9);
1535 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1537 return TEST_SUCCESS
;
1540 static test_return_t
mget_result_test(memcached_st
*memc
)
1542 const char *keys
[]= {"fudge", "son", "food"};
1543 size_t key_length
[]= {5, 3, 4};
1545 memcached_result_st results_obj
;
1546 memcached_result_st
*results
;
1548 results
= memcached_result_create(memc
, &results_obj
);
1550 test_true(&results_obj
== results
);
1552 /* We need to empty the server before continueing test */
1553 test_compare(MEMCACHED_SUCCESS
,
1554 memcached_flush(memc
, 0));
1556 test_compare(MEMCACHED_SUCCESS
,
1557 memcached_mget(memc
, keys
, key_length
, 3));
1559 memcached_return_t rc
;
1560 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1565 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1566 test_false(results
);
1567 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1569 for (uint32_t x
= 0; x
< 3; x
++)
1571 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1572 keys
[x
], key_length
[x
],
1573 (time_t)50, (uint32_t)9);
1574 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1577 test_compare(MEMCACHED_SUCCESS
,
1578 memcached_mget(memc
, keys
, key_length
, 3));
1580 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1583 test_true(&results_obj
== results
);
1584 test_compare(MEMCACHED_SUCCESS
, rc
);
1585 test_memcmp(memcached_result_key_value(results
),
1586 memcached_result_value(results
),
1587 memcached_result_length(results
));
1588 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1591 memcached_result_free(&results_obj
);
1593 return TEST_SUCCESS
;
1596 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1598 const char *keys
[]= {"fudge", "son", "food"};
1599 size_t key_length
[]= {5, 3, 4};
1601 memcached_result_st
*results
;
1603 /* We need to empty the server before continueing test */
1604 test_compare(MEMCACHED_SUCCESS
,
1605 memcached_flush(memc
, 0));
1607 test_compare(MEMCACHED_SUCCESS
,
1608 memcached_mget(memc
, keys
, key_length
, 3));
1610 memcached_return_t rc
;
1611 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1615 test_false(results
);
1616 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1618 for (uint32_t x
= 0; x
< 3; x
++)
1620 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1621 keys
[x
], key_length
[x
],
1622 (time_t)50, (uint32_t)9);
1623 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1626 test_compare(MEMCACHED_SUCCESS
,
1627 memcached_mget(memc
, keys
, key_length
, 3));
1630 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1633 test_compare(MEMCACHED_SUCCESS
, rc
);
1634 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1635 test_memcmp(memcached_result_key_value(results
),
1636 memcached_result_value(results
),
1637 memcached_result_length(results
));
1638 memcached_result_free(results
);
1642 return TEST_SUCCESS
;
1645 /* Count the results */
1646 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1648 size_t *counter
= (size_t *)context
;
1650 *counter
= *counter
+ 1;
1652 return MEMCACHED_SUCCESS
;
1655 static test_return_t
mget_result_function(memcached_st
*memc
)
1657 const char *keys
[]= {"fudge", "son", "food"};
1658 size_t key_length
[]= {5, 3, 4};
1660 memcached_execute_fn callbacks
[1];
1662 /* We need to empty the server before continueing test */
1663 test_compare(MEMCACHED_SUCCESS
,
1664 memcached_flush(memc
, 0));
1665 for (uint32_t x
= 0; x
< 3; x
++)
1667 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1668 keys
[x
], key_length
[x
],
1669 (time_t)50, (uint32_t)9);
1670 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1673 test_compare(MEMCACHED_SUCCESS
,
1674 memcached_mget(memc
, keys
, key_length
, 3));
1676 callbacks
[0]= &callback_counter
;
1679 test_compare(MEMCACHED_SUCCESS
,
1680 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1682 test_compare(size_t(3), counter
);
1684 return TEST_SUCCESS
;
1687 static test_return_t
mget_test(memcached_st
*memc
)
1689 const char *keys
[]= {"fudge", "son", "food"};
1690 size_t key_length
[]= {5, 3, 4};
1692 char return_key
[MEMCACHED_MAX_KEY
];
1693 size_t return_key_length
;
1695 size_t return_value_length
;
1697 /* We need to empty the server before continueing test */
1698 test_compare(MEMCACHED_SUCCESS
,
1699 memcached_flush(memc
, 0));
1701 test_compare(MEMCACHED_SUCCESS
,
1702 memcached_mget(memc
, keys
, key_length
, 3));
1705 memcached_return_t rc
;
1706 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1707 &return_value_length
, &flags
, &rc
)))
1709 test_true(return_value
);
1711 test_false(return_value
);
1712 test_zero(return_value_length
);
1713 test_compare(MEMCACHED_NOTFOUND
, rc
);
1715 for (uint32_t x
= 0; x
< 3; x
++)
1717 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1718 keys
[x
], key_length
[x
],
1719 (time_t)50, (uint32_t)9);
1720 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1722 test_compare(MEMCACHED_SUCCESS
,
1723 memcached_mget(memc
, keys
, key_length
, 3));
1726 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1727 &return_value_length
, &flags
, &rc
)))
1729 test_true(return_value
);
1730 test_compare(MEMCACHED_SUCCESS
, rc
);
1731 if (not memc
->_namespace
)
1733 test_compare(return_key_length
, return_value_length
);
1734 test_memcmp(return_value
, return_key
, return_value_length
);
1740 return TEST_SUCCESS
;
1743 static test_return_t
mget_execute(memcached_st
*memc
)
1747 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1751 * I only want to hit _one_ server so I know the number of requests I'm
1752 * sending in the pipeline.
1754 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1755 memc
->number_of_hosts
= 1;
1757 size_t max_keys
= 20480;
1760 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1761 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1763 /* First add all of the items.. */
1764 char blob
[1024] = {0};
1765 memcached_return_t rc
;
1767 for (size_t x
= 0; x
< max_keys
; ++x
)
1771 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1773 test_true(keys
[x
] != NULL
);
1774 uint64_t query_id
= memcached_query_id(memc
);
1775 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1776 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1777 test_compare(query_id
+1, memcached_query_id(memc
));
1780 /* Try to get all of them with a large multiget */
1782 memcached_execute_fn callbacks
[]= { &callback_counter
};
1783 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1784 max_keys
, callbacks
, &counter
, 1);
1786 if (memcached_success(rc
))
1789 uint64_t query_id
= memcached_query_id(memc
);
1790 test_compare(MEMCACHED_SUCCESS
,
1791 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1792 test_compare(query_id
, memcached_query_id(memc
));
1794 /* Verify that we got all of the items */
1795 test_true(counter
== max_keys
);
1797 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1799 test_true(counter
== 0);
1803 test_fail("note: this test functions differently when in binary mode");
1806 /* Release all allocated resources */
1807 for (size_t x
= 0; x
< max_keys
; ++x
)
1814 memc
->number_of_hosts
= number_of_hosts
;
1815 return TEST_SUCCESS
;
1818 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1820 static test_return_t
key_setup(memcached_st
*memc
)
1822 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1824 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1826 return TEST_SUCCESS
;
1829 static test_return_t
key_teardown(memcached_st
*memc
)
1832 pairs_free(global_pairs
);
1834 return TEST_SUCCESS
;
1837 static test_return_t
block_add_regression(memcached_st
*memc
)
1839 /* First add all of the items.. */
1840 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1842 memcached_return_t rc
;
1843 char blob
[1024] = {0};
1845 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1846 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1849 return TEST_SUCCESS
;
1852 static test_return_t
binary_add_regression(memcached_st
*memc
)
1854 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1855 test_return_t rc
= block_add_regression(memc
);
1856 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1860 static test_return_t
get_stats_keys(memcached_st
*memc
)
1864 memcached_stat_st memc_stat
;
1865 memcached_return_t rc
;
1867 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1868 test_compare(MEMCACHED_SUCCESS
, rc
);
1869 for (ptr
= stat_list
; *ptr
; ptr
++)
1874 return TEST_SUCCESS
;
1877 static test_return_t
version_string_test(memcached_st
*)
1879 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1881 return TEST_SUCCESS
;
1884 static test_return_t
get_stats(memcached_st
*memc
)
1886 memcached_return_t rc
;
1888 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1889 test_compare(MEMCACHED_SUCCESS
, rc
);
1890 test_true(memc_stat
);
1892 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1894 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1895 test_compare(MEMCACHED_SUCCESS
, rc
);
1896 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1901 memcached_stat_free(NULL
, memc_stat
);
1903 return TEST_SUCCESS
;
1906 static test_return_t
add_host_test(memcached_st
*memc
)
1908 char servername
[]= "0.example.com";
1910 memcached_return_t rc
;
1911 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1912 test_compare(1U, memcached_server_list_count(servers
));
1914 for (unsigned int x
= 2; x
< 20; x
++)
1916 char buffer
[SMALL_STRING_LEN
];
1918 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1919 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1921 test_compare(MEMCACHED_SUCCESS
, rc
);
1922 test_compare(x
, memcached_server_list_count(servers
));
1925 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1926 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1928 memcached_server_list_free(servers
);
1930 return TEST_SUCCESS
;
1933 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1935 memcached_return_t rc
;
1937 const char *key
= "not_found";
1938 size_t key_length
= test_literal_param_size("not_found");
1940 test_compare(MEMCACHED_SUCCESS
,
1941 memcached_mget(memc
, &key
, &key_length
, 1));
1943 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1945 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1947 memcached_result_free(result
);
1949 return TEST_SUCCESS
;
1952 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1954 return MEMCACHED_SUCCESS
;
1957 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1959 return MEMCACHED_SUCCESS
;
1962 static test_return_t
callback_test(memcached_st
*memc
)
1964 /* Test User Data */
1968 memcached_return_t rc
;
1970 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1971 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1972 test_true(*test_ptr
== x
);
1975 /* Test Clone Callback */
1977 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1978 void *clone_cb_ptr
= *(void **)&clone_cb
;
1979 void *temp_function
= NULL
;
1981 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
1982 memcached_return_t rc
;
1983 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1984 test_true(temp_function
== clone_cb_ptr
);
1985 test_compare(MEMCACHED_SUCCESS
, rc
);
1988 /* Test Cleanup Callback */
1990 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
1991 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1992 void *temp_function
= NULL
;
1993 memcached_return_t rc
;
1995 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
1996 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1997 test_true(temp_function
== cleanup_cb_ptr
);
2000 return TEST_SUCCESS
;
2003 /* We don't test the behavior itself, we test the switches */
2004 static test_return_t
behavior_test(memcached_st
*memc
)
2006 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2007 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2009 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2010 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2012 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2013 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2015 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2016 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2018 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2019 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2021 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2022 test_compare(MEMCACHED_HASH_DEFAULT
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2024 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2025 test_compare(MEMCACHED_HASH_CRC
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2027 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2028 test_true(value
> 0);
2030 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2031 test_true(value
> 0);
2033 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2034 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2035 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2037 return TEST_SUCCESS
;
2040 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2042 test_compare(MEMCACHED_DEPRECATED
,
2043 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2045 // Platform dependent
2047 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2051 return TEST_SUCCESS
;
2055 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2057 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2058 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2060 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2062 if (memcached_success(rc
))
2071 return TEST_SUCCESS
;
2075 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2077 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2078 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2080 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2082 if (memcached_success(rc
))
2091 return TEST_SUCCESS
;
2094 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, const memcached_return_t expect
)
2096 memcached_return_t rc
;
2097 char return_key
[MEMCACHED_MAX_KEY
];
2098 size_t return_key_length
;
2100 size_t return_value_length
;
2104 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2105 &return_value_length
, &flags
, &rc
)))
2107 test_true(return_value
);
2108 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2113 if (memcached_success(expect
) and memcached_success(rc
))
2115 return TEST_SUCCESS
;
2117 else if (expect
== rc
)
2119 return TEST_SUCCESS
;
2121 fprintf(stderr
, "\n%s:%u %s(#%u)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), keys_returned
);
2123 return TEST_FAILURE
;
2126 /* Test case provided by Cal Haldenbrand */
2127 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2128 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2129 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2131 /* We just keep looking at the same values over and over */
2134 test_compare(MEMCACHED_SUCCESS
,
2135 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2136 test_compare(MEMCACHED_SUCCESS
,
2137 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2141 unsigned long long total
= 0;
2142 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2144 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2145 char randomstuff
[6 * 1024];
2146 memset(randomstuff
, 0, 6 * 1024);
2147 test_true(size
< 6 * 1024); /* Being safe here */
2149 for (uint32_t j
= 0 ; j
< size
;j
++)
2151 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2156 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2157 test_compare(MEMCACHED_SUCCESS
,
2158 memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
));
2160 test_true(total
> HALDENBRAND_KEY_COUNT
);
2162 return TEST_SUCCESS
;
2165 /* Test case provided by Cal Haldenbrand */
2166 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2168 test_compare(MEMCACHED_SUCCESS
,
2169 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2171 test_compare(MEMCACHED_SUCCESS
,
2172 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2175 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576));
2176 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576));
2177 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2178 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2180 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2183 size_t total_value_length
= 0;
2184 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2189 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2190 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2192 memcached_return_t rc
;
2193 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2194 if (memcached_failed(rc
))
2196 if (rc
== MEMCACHED_NOTFOUND
)
2207 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2209 total_value_length
+= val_len
;
2214 return TEST_SUCCESS
;
2217 /* Do a large mget() over all the keys we think exist */
2218 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2220 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
2221 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
2224 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576);
2225 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576);
2226 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2227 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2230 size_t key_lengths
[HALDENBRAND_KEY_COUNT
];
2231 char **keys
= static_cast<char **>(calloc(HALDENBRAND_KEY_COUNT
, sizeof(char *)));
2233 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2235 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2236 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2237 test_true(key_length
);
2238 keys
[x
]= strdup(key
);
2240 key_lengths
[x
]= key_length
;
2241 test_compare(size_t(key_length
), strlen(keys
[x
]));
2244 test_compare(MEMCACHED_SUCCESS
,
2245 memcached_mget(memc
, (const char **)keys
, key_lengths
, HALDENBRAND_KEY_COUNT
));
2247 unsigned int keys_returned
;
2248 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
2249 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2251 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2257 return TEST_SUCCESS
;
2260 /* Make sure we behave properly if server list has no values */
2261 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2263 const char *keys
[]= {"fudge", "son", "food"};
2264 size_t key_length
[]= {5, 3, 4};
2266 /* Here we free everything before running a bunch of mget tests */
2267 memcached_servers_reset(memc
);
2270 /* We need to empty the server before continueing test */
2271 test_compare(MEMCACHED_NO_SERVERS
,
2272 memcached_flush(memc
, 0));
2274 test_compare(MEMCACHED_NO_SERVERS
,
2275 memcached_mget(memc
, keys
, key_length
, 3));
2277 unsigned int keys_returned
;
2278 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2279 test_zero(keys_returned
);
2281 for (uint32_t x
= 0; x
< 3; x
++)
2283 test_compare(MEMCACHED_NO_SERVERS
,
2284 memcached_set(memc
, keys
[x
], key_length
[x
],
2285 keys
[x
], key_length
[x
],
2286 (time_t)50, (uint32_t)9));
2289 test_compare(MEMCACHED_NO_SERVERS
,
2290 memcached_mget(memc
, keys
, key_length
, 3));
2294 char return_key
[MEMCACHED_MAX_KEY
];
2295 memcached_return_t rc
;
2296 size_t return_key_length
;
2297 size_t return_value_length
;
2300 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2301 &return_value_length
, &flags
, &rc
)))
2303 test_true(return_value
);
2304 test_compare(MEMCACHED_SUCCESS
, rc
);
2305 test_true(return_key_length
== return_value_length
);
2306 test_memcmp(return_value
, return_key
, return_value_length
);
2312 return TEST_SUCCESS
;
2315 #define VALUE_SIZE_BUG5 1048064
2316 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2318 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2319 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2321 size_t value_length
;
2323 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2325 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2327 insert_data
[x
]= (signed char)rand();
2330 test_compare(MEMCACHED_SUCCESS
,
2331 memcached_flush(memc
, 0));
2333 memcached_return_t rc
;
2334 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2335 test_compare(MEMCACHED_SUCCESS
,
2336 memcached_mget(memc
, keys
, key_length
, 4));
2339 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2342 for (uint32_t x
= 0; x
< 4; x
++)
2344 test_compare(MEMCACHED_SUCCESS
,
2345 memcached_set(memc
, keys
[x
], key_length
[x
],
2346 insert_data
, VALUE_SIZE_BUG5
,
2347 (time_t)0, (uint32_t)0));
2350 for (uint32_t x
= 0; x
< 10; x
++)
2352 value
= memcached_get(memc
, keys
[0], key_length
[0],
2353 &value_length
, &flags
, &rc
);
2354 test_compare(rc
, MEMCACHED_SUCCESS
);
2358 test_compare(MEMCACHED_SUCCESS
,
2359 memcached_mget(memc
, keys
, key_length
, 4));
2361 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2362 test_compare(4U, count
);
2364 delete [] insert_data
;
2366 return TEST_SUCCESS
;
2369 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2371 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2372 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2373 char return_key
[MEMCACHED_MAX_KEY
];
2374 size_t return_key_length
;
2376 size_t value_length
;
2378 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2380 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2382 insert_data
[x
]= (signed char)rand();
2385 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2387 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2389 // We will now confirm that memcached_mget() returns success, but we will
2390 // then check to make sure that no actual keys are returned.
2391 test_compare(MEMCACHED_SUCCESS
,
2392 memcached_mget(memc
, keys
, key_length
, 4));
2394 memcached_return_t rc
;
2396 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2397 &value_length
, &flags
, &rc
)))
2402 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2404 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2406 test_compare(MEMCACHED_SUCCESS
,
2407 memcached_set(memc
, keys
[x
], key_length
[x
],
2408 insert_data
, VALUE_SIZE_BUG5
,
2409 (time_t)0, (uint32_t)0));
2411 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2413 for (uint32_t x
= 0; x
< 2; x
++)
2415 value
= memcached_get(memc
, keys
[0], key_length
[0],
2416 &value_length
, &flags
, &rc
);
2420 test_compare(MEMCACHED_SUCCESS
,
2421 memcached_mget(memc
, keys
, key_length
, 4));
2422 /* We test for purge of partial complete fetches */
2423 for (count
= 3; count
; count
--)
2425 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2426 &value_length
, &flags
, &rc
);
2427 test_compare(MEMCACHED_SUCCESS
, rc
);
2428 test_memcmp(value
, insert_data
, value_length
);
2429 test_true(value_length
);
2433 delete [] insert_data
;
2435 return TEST_SUCCESS
;
2438 static test_return_t
user_supplied_bug8(memcached_st
*)
2440 memcached_return_t rc
;
2442 memcached_st
*memc_clone
;
2444 memcached_server_st
*servers
;
2445 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";
2447 servers
= memcached_servers_parse(server_list
);
2450 mine
= memcached_create(NULL
);
2451 rc
= memcached_server_push(mine
, servers
);
2452 test_compare(MEMCACHED_SUCCESS
, rc
);
2453 memcached_server_list_free(servers
);
2456 memc_clone
= memcached_clone(NULL
, mine
);
2458 memcached_quit(mine
);
2459 memcached_quit(memc_clone
);
2462 memcached_free(mine
);
2463 memcached_free(memc_clone
);
2465 return TEST_SUCCESS
;
2468 /* Test flag store/retrieve */
2469 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2471 const char *keys
= "036790384900";
2472 size_t key_length
= strlen(keys
);
2473 char return_key
[MEMCACHED_MAX_KEY
];
2474 size_t return_key_length
;
2476 size_t value_length
;
2478 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2480 for (unsigned int x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2482 insert_data
[x
]= (signed char)rand();
2485 memcached_flush(memc
, 0);
2488 memcached_return_t rc
= memcached_set(memc
, keys
, key_length
,
2489 insert_data
, VALUE_SIZE_BUG5
,
2491 test_compare(MEMCACHED_SUCCESS
, rc
);
2494 value
= memcached_get(memc
, keys
, key_length
,
2495 &value_length
, &flags
, &rc
);
2496 test_compare(245U, flags
);
2500 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2503 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2504 &value_length
, &flags
, &rc
);
2505 test_compare(uint32_t(245), flags
);
2508 delete [] insert_data
;
2511 return TEST_SUCCESS
;
2514 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2516 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2517 size_t key_length
[3];
2521 char return_key
[MEMCACHED_MAX_KEY
];
2522 size_t return_key_length
;
2524 size_t return_value_length
;
2527 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2528 key_length
[1]= strlen("fudge&*@#");
2529 key_length
[2]= strlen("for^#@&$not");
2532 for (unsigned int x
= 0; x
< 3; x
++)
2534 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2535 keys
[x
], key_length
[x
],
2536 (time_t)50, (uint32_t)9);
2537 test_compare(MEMCACHED_SUCCESS
, rc
);
2540 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2541 test_compare(MEMCACHED_SUCCESS
, rc
);
2543 /* We need to empty the server before continueing test */
2544 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2545 &return_value_length
, &flags
, &rc
)) != NULL
)
2547 test_true(return_value
);
2551 test_compare(3U, count
);
2553 return TEST_SUCCESS
;
2556 /* We are testing with aggressive timeout to get failures */
2557 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2559 size_t value_length
= 512;
2560 unsigned int set
= 1;
2561 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2563 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2564 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2565 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2567 std::vector
<char> value
;
2568 value
.reserve(value_length
);
2569 for (uint32_t x
= 0; x
< value_length
; x
++)
2571 value
.push_back(char(x
% 127));
2574 for (unsigned int x
= 1; x
<= 100000; ++x
)
2576 memcached_return_t rc
= memcached_set(mclone
,
2577 test_literal_param("foo"),
2578 &value
[0], value
.size(),
2581 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2582 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2583 memcached_strerror(NULL
, rc
));
2585 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2591 memcached_free(mclone
);
2593 return TEST_SUCCESS
;
2597 We are looking failures in the async protocol
2599 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2601 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2603 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2604 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2605 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2607 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2610 std::vector
<char> value
;
2612 for (unsigned int x
= 0; x
< 512; x
++)
2614 value
.push_back(char(x
% 127));
2617 for (unsigned int x
= 1; x
<= 100000; ++x
)
2619 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2623 memcached_free(mclone
);
2625 return TEST_SUCCESS
;
2629 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2631 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2633 memcached_return_t rc
;
2635 size_t value_length
;
2637 uint64_t number_value
;
2639 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2640 &value_length
, &flags
, &rc
);
2641 test_true(value
== NULL
);
2642 test_compare(MEMCACHED_NOTFOUND
, rc
);
2644 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2646 test_true(value
== NULL
);
2647 /* The binary protocol will set the key if it doesn't exist */
2648 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2650 test_compare(MEMCACHED_SUCCESS
, rc
);
2654 test_compare(MEMCACHED_NOTFOUND
, rc
);
2657 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2659 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2660 &value_length
, &flags
, &rc
);
2662 test_compare(MEMCACHED_SUCCESS
, rc
);
2665 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2667 test_true(number_value
== 2);
2668 test_compare(MEMCACHED_SUCCESS
, rc
);
2670 return TEST_SUCCESS
;
2674 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2675 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2677 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2679 char key
[] = "key34567890";
2680 memcached_return_t rc
;
2681 size_t overflowSize
;
2683 char commandFirst
[]= "set key34567890 0 0 ";
2684 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2685 size_t commandLength
;
2688 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2690 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2692 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2694 char *overflow
= new (std::nothrow
) char[testSize
];
2695 test_true(overflow
);
2697 memset(overflow
, 'x', testSize
);
2698 rc
= memcached_set(memc
, key
, strlen(key
),
2699 overflow
, testSize
, 0, 0);
2700 test_compare(MEMCACHED_SUCCESS
, rc
);
2704 return TEST_SUCCESS
;
2709 Test values of many different sizes
2710 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2711 set key34567890 0 0 8169 \r\n
2712 is sent followed by buffer of size 8169, followed by 8169
2714 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2716 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2718 std::vector
<char> value
;
2719 value
.reserve(18000);
2720 for (size_t x
= 0; x
< 18000; x
++)
2722 value
.push_back((char) (x
% 127));
2725 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2727 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2728 &value
[0], current_length
,
2729 (time_t)0, (uint32_t)0);
2730 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2732 size_t string_length
;
2734 char *string
= memcached_get(memc
, test_literal_param("foo"),
2735 &string_length
, &flags
, &rc
);
2737 test_compare(MEMCACHED_SUCCESS
, rc
);
2738 test_compare(string_length
, current_length
);
2739 test_memcmp(string
, &value
[0], string_length
);
2744 return TEST_SUCCESS
;
2748 Look for zero length value problems
2750 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2752 for (uint32_t x
= 0; x
< 2; x
++)
2754 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2756 (time_t)0, (uint32_t)0);
2758 test_compare(MEMCACHED_SUCCESS
, rc
);
2762 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2763 &length
, &flags
, &rc
);
2765 test_compare(MEMCACHED_SUCCESS
, rc
);
2770 value
= memcached_get(memc
, test_literal_param("mykey"),
2771 &length
, &flags
, &rc
);
2773 test_compare(MEMCACHED_SUCCESS
, rc
);
2774 test_true(value
== NULL
);
2779 return TEST_SUCCESS
;
2782 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2783 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2785 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2787 (time_t)0, UINT32_MAX
);
2789 test_compare(MEMCACHED_SUCCESS
, rc
);
2793 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2794 &length
, &flags
, &rc
);
2796 test_compare(MEMCACHED_SUCCESS
, rc
);
2797 test_true(value
== NULL
);
2799 test_compare(flags
, UINT32_MAX
);
2801 return TEST_SUCCESS
;
2804 #if !defined(__sun) && !defined(__OpenBSD__)
2805 /* Check the validity of chinese key*/
2806 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2808 const char *key
= "豆瓣";
2809 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2810 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2811 value
, strlen(value
),
2814 test_compare(MEMCACHED_SUCCESS
, rc
);
2818 char *value2
= memcached_get(memc
, key
, strlen(key
),
2819 &length
, &flags
, &rc
);
2821 test_true(length
==strlen(value
));
2822 test_compare(MEMCACHED_SUCCESS
, rc
);
2823 test_memcmp(value
, value2
, length
);
2826 return TEST_SUCCESS
;
2834 static test_return_t
user_supplied_bug19(memcached_st
*)
2836 memcached_return_t res
;
2838 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2840 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2843 memcached_free(memc
);
2845 return TEST_SUCCESS
;
2848 /* CAS test from Andei */
2849 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2851 const char *key
= "abc";
2852 size_t key_len
= strlen("abc");
2854 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2856 test_compare(MEMCACHED_SUCCESS
,
2858 test_literal_param("abc"),
2859 test_literal_param("foobar"),
2860 (time_t)0, (uint32_t)0));
2862 test_compare(MEMCACHED_SUCCESS
,
2863 memcached_mget(memc
, &key
, &key_len
, 1));
2865 memcached_result_st result_obj
;
2866 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2869 memcached_result_create(memc
, &result_obj
);
2870 memcached_return_t status
;
2871 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2874 test_compare(MEMCACHED_SUCCESS
, status
);
2876 memcached_result_free(result
);
2878 return TEST_SUCCESS
;
2881 /* Large mget() of missing keys with binary proto
2883 * If many binary quiet commands (such as getq's in an mget) fill the output
2884 * buffer and the server chooses not to respond, memcached_flush hangs. See
2885 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2888 /* sighandler_t function that always asserts false */
2889 static void fail(int)
2895 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2900 return TEST_SKIPPED
;
2902 void (*oldalarm
)(int);
2904 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2905 test_true(memc_clone
);
2907 /* only binproto uses getq for mget */
2908 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2910 /* empty the cache to ensure misses (hence non-responses) */
2911 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2913 size_t* key_lengths
= new (std::nothrow
) size_t[key_count
];
2914 test_true(key_lengths
);
2915 char **keys
= static_cast<char **>(calloc(key_count
, sizeof(char *)));
2917 for (unsigned int x
= 0; x
< key_count
; x
++)
2921 snprintf(buffer
, 30, "%u", x
);
2922 keys
[x
]= strdup(buffer
);
2924 key_lengths
[x
]= strlen(keys
[x
]);
2927 oldalarm
= signal(SIGALRM
, fail
);
2930 test_compare_got(MEMCACHED_SUCCESS
,
2931 memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
), memcached_last_error_message(memc_clone
));
2934 signal(SIGALRM
, oldalarm
);
2936 memcached_return_t rc
;
2938 char return_key
[MEMCACHED_MAX_KEY
];
2939 size_t return_key_length
;
2941 size_t return_value_length
;
2942 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2943 &return_value_length
, &flags
, &rc
)))
2945 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2947 test_compare(MEMCACHED_NOTFOUND
, rc
);
2948 test_zero(return_value_length
);
2949 test_zero(return_key_length
);
2950 test_false(return_key
[0]);
2951 test_false(return_value
);
2953 for (unsigned int x
= 0; x
< key_count
; x
++)
2958 delete [] key_lengths
;
2960 memcached_free(memc_clone
);
2962 return TEST_SUCCESS
;
2966 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
2968 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2970 /* should work as of r580 */
2971 test_compare(TEST_SUCCESS
,
2972 _user_supplied_bug21(memc
, 10));
2974 /* should fail as of r580 */
2975 test_compare(TEST_SUCCESS
,
2976 _user_supplied_bug21(memc
, 1000));
2978 return TEST_SUCCESS
;
2981 static test_return_t
output_ketama_weighted_keys(memcached_st
*)
2983 memcached_st
*memc
= memcached_create(NULL
);
2987 test_compare(MEMCACHED_SUCCESS
,
2988 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2990 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2991 test_compare(value
, uint64_t(1));
2993 test_compare(MEMCACHED_SUCCESS
,
2994 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2996 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2997 test_true(value
== MEMCACHED_HASH_MD5
);
3000 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3002 memcached_server_st
*server_pool
;
3003 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");
3004 memcached_server_push(memc
, server_pool
);
3006 // @todo this needs to be refactored to actually test something.
3009 if ((fp
= fopen("ketama_keys.txt", "w")))
3013 printf("cannot write to file ketama_keys.txt");
3014 return TEST_FAILURE
;
3017 for (int x
= 0; x
< 10000; x
++)
3020 snprintf(key
, sizeof(key
), "%d", x
);
3022 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3023 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3024 in_port_t port
= memc
->hosts
[server_idx
].port
;
3025 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3026 memcached_server_instance_st instance
=
3027 memcached_server_instance_by_position(memc
, host_index
);
3031 memcached_server_list_free(server_pool
);
3032 memcached_free(memc
);
3034 return TEST_SUCCESS
;
3038 static test_return_t
result_static(memcached_st
*memc
)
3040 memcached_result_st result
;
3041 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3042 test_false(result
.options
.is_allocated
);
3043 test_true(memcached_is_initialized(&result
));
3044 test_true(result_ptr
);
3045 test_true(result_ptr
== &result
);
3047 memcached_result_free(&result
);
3049 test_false(result
.options
.is_allocated
);
3050 test_false(memcached_is_initialized(&result
));
3052 return TEST_SUCCESS
;
3055 static test_return_t
result_alloc(memcached_st
*memc
)
3057 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3058 test_true(result_ptr
);
3059 test_true(result_ptr
->options
.is_allocated
);
3060 test_true(memcached_is_initialized(result_ptr
));
3061 memcached_result_free(result_ptr
);
3063 return TEST_SUCCESS
;
3066 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3069 pairs_free(global_pairs
);
3071 return TEST_SUCCESS
;
3074 static test_return_t
generate_pairs(memcached_st
*)
3076 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3077 global_count
= GLOBAL_COUNT
;
3079 for (size_t x
= 0; x
< global_count
; x
++)
3081 global_keys
[x
]= global_pairs
[x
].key
;
3082 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3085 return TEST_SUCCESS
;
3088 static test_return_t
generate_large_pairs(memcached_st
*)
3090 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3091 global_count
= GLOBAL2_COUNT
;
3093 for (size_t x
= 0; x
< global_count
; x
++)
3095 global_keys
[x
]= global_pairs
[x
].key
;
3096 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3099 return TEST_SUCCESS
;
3102 static test_return_t
generate_data(memcached_st
*memc
)
3104 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3106 test_compare(check_execute
, global_count
);
3108 return TEST_SUCCESS
;
3111 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3113 uint32_t host_index
= 0;
3114 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3116 test_true(check_execute
== global_count
);
3118 // @todo hosts used size stats
3119 memcached_return_t rc
;
3120 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3123 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3125 /* This test was changes so that "make test" would work properlly */
3128 memcached_server_instance_st instance
=
3129 memcached_server_instance_by_position(memc
, host_index
);
3131 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3133 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3136 memcached_stat_free(NULL
, stat_p
);
3138 return TEST_SUCCESS
;
3140 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3142 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3143 generate_data(memc
);
3145 return TEST_SUCCESS
;
3148 static test_return_t
get_read_count(memcached_st
*memc
)
3150 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3151 test_true(memc_clone
);
3153 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3157 size_t return_value_length
;
3161 for (size_t x
= count
= 0; x
< global_count
; x
++)
3163 memcached_return_t rc
;
3164 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3165 &return_value_length
, &flags
, &rc
);
3166 if (rc
== MEMCACHED_SUCCESS
)
3177 memcached_free(memc_clone
);
3179 return TEST_SUCCESS
;
3182 static test_return_t
get_read(memcached_st
*memc
)
3184 for (size_t x
= 0; x
< global_count
; x
++)
3186 size_t return_value_length
;
3188 memcached_return_t rc
;
3189 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3190 &return_value_length
, &flags
, &rc
);
3192 test_true(return_value);
3193 test_compare(MEMCACHED_SUCCESS, rc);
3195 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3201 return TEST_SUCCESS
;
3204 static test_return_t
mget_read(memcached_st
*memc
)
3207 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3209 test_compare(MEMCACHED_SUCCESS
,
3210 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3212 // Go fetch the keys and test to see if all of them were returned
3214 unsigned int keys_returned
;
3215 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3216 test_true(keys_returned
> 0);
3217 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3220 return TEST_SUCCESS
;
3223 static test_return_t
mget_read_result(memcached_st
*memc
)
3226 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3228 test_compare(MEMCACHED_SUCCESS
,
3229 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3231 /* Turn this into a help function */
3233 memcached_result_st results_obj
;
3234 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3237 memcached_return_t rc
;
3238 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3240 if (rc
== MEMCACHED_IN_PROGRESS
)
3246 test_compare(MEMCACHED_SUCCESS
, rc
);
3248 test_compare(MEMCACHED_END
, rc
);
3250 memcached_result_free(&results_obj
);
3253 return TEST_SUCCESS
;
3256 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3259 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3261 test_compare(MEMCACHED_SUCCESS
,
3262 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3264 memcached_result_st
*results
= NULL
;
3265 memcached_return_t rc
;
3266 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3269 test_compare(MEMCACHED_SUCCESS
, rc
);
3271 test_compare(MEMCACHED_END
, rc
);
3273 memcached_result_free(results
);
3276 return TEST_SUCCESS
;
3279 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3282 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3284 test_compare(MEMCACHED_SUCCESS
,
3285 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3287 // We will scan for just one key
3289 memcached_result_st results_obj
;
3290 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3292 memcached_return_t rc
;
3293 results
= memcached_fetch_result(memc
, results
, &rc
);
3295 test_compare(MEMCACHED_SUCCESS
, rc
);
3297 memcached_result_free(&results_obj
);
3300 // We already have a read happening, lets start up another one.
3301 test_compare(MEMCACHED_SUCCESS
,
3302 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3304 memcached_result_st results_obj
;
3305 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3307 test_false(memcached_is_allocated(results
));
3309 memcached_return_t rc
;
3310 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3313 test_compare(MEMCACHED_SUCCESS
, rc
);
3315 test_compare(MEMCACHED_END
, rc
);
3317 memcached_result_free(&results_obj
);
3320 return TEST_SUCCESS
;
3323 static test_return_t
mget_read_function(memcached_st
*memc
)
3325 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3327 test_compare(MEMCACHED_SUCCESS
,
3328 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3330 memcached_execute_fn callbacks
[]= { &callback_counter
};
3332 test_compare(MEMCACHED_SUCCESS
,
3333 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3335 return TEST_SUCCESS
;
3338 static test_return_t
delete_generate(memcached_st
*memc
)
3340 for (size_t x
= 0; x
< global_count
; x
++)
3342 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3345 return TEST_SUCCESS
;
3348 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3350 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3352 for (size_t x
= 0; x
< global_count
; x
++)
3354 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3357 return TEST_SUCCESS
;
3360 static test_return_t
add_host_test1(memcached_st
*memc
)
3362 memcached_return_t rc
;
3363 char servername
[]= "0.example.com";
3365 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3367 test_compare(1U, memcached_server_list_count(servers
));
3369 for (uint32_t x
= 2; x
< 20; x
++)
3371 char buffer
[SMALL_STRING_LEN
];
3373 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3374 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3376 test_compare(MEMCACHED_SUCCESS
, rc
);
3377 test_compare(x
, memcached_server_list_count(servers
));
3380 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3381 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3383 memcached_server_list_free(servers
);
3385 return TEST_SUCCESS
;
3388 static test_return_t
pre_nonblock(memcached_st
*memc
)
3390 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3392 return TEST_SUCCESS
;
3395 static test_return_t
pre_cork(memcached_st
*memc
)
3398 return TEST_SKIPPED
;
3401 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3402 return TEST_SUCCESS
;
3404 return TEST_SKIPPED
;
3407 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3410 return TEST_SKIPPED
;
3412 test_return_t test_rc
;
3413 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3416 return pre_nonblock(memc
);
3419 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3421 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3422 test_true(memc_clone
);
3424 // The memcached_version needs to be done on a clone, because the server
3425 // will not toggle protocol on an connection.
3426 memcached_version(memc_clone
);
3428 memcached_return_t rc
= MEMCACHED_FAILURE
;
3429 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3431 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3432 test_compare(MEMCACHED_SUCCESS
,
3433 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3434 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3438 memcached_free(memc_clone
);
3439 return TEST_SKIPPED
;
3442 memcached_free(memc_clone
);
3444 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3447 static test_return_t
pre_murmur(memcached_st
*memc
)
3449 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3450 return TEST_SUCCESS
;
3453 static test_return_t
pre_jenkins(memcached_st
*memc
)
3455 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3457 return TEST_SUCCESS
;
3461 static test_return_t
pre_md5(memcached_st
*memc
)
3463 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3465 return TEST_SUCCESS
;
3468 static test_return_t
pre_crc(memcached_st
*memc
)
3470 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3472 return TEST_SUCCESS
;
3475 static test_return_t
pre_hsieh(memcached_st
*memc
)
3477 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
));
3478 return TEST_SUCCESS
;
3481 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3483 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3485 return TEST_SUCCESS
;
3488 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3490 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
));
3492 return TEST_SUCCESS
;
3495 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3497 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3499 return TEST_SUCCESS
;
3502 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3504 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3506 return TEST_SUCCESS
;
3509 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3511 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3512 test_compare(MEMCACHED_SUCCESS
, rc
);
3514 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3515 test_compare(value
, uint64_t(1));
3517 return TEST_SUCCESS
;
3520 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3522 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3523 test_compare(MEMCACHED_SUCCESS
, rc
);
3525 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3526 test_compare(value
, uint64_t(1));
3528 test_compare(MEMCACHED_SUCCESS
,
3529 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3531 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3532 test_compare(MEMCACHED_HASH_MD5
, memcached_hash_t(value
));
3534 return TEST_SUCCESS
;
3537 static test_return_t
pre_replication(memcached_st
*memc
)
3539 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3542 * Make sure that we store the item on all servers
3543 * (master + replicas == number of servers)
3545 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3546 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3548 return TEST_SUCCESS
;
3552 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3554 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3556 return pre_nonblock(memc
);
3560 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3564 #ifdef HARD_MALLOC_TESTS
3565 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3573 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3577 #ifdef HARD_MALLOC_TESTS
3578 void *ret
= malloc(size
+ 8);
3581 ret
= (void*)((caddr_t
)ret
+ 8);
3584 void *ret
= malloc(size
);
3589 memset(ret
, 0xff, size
);
3596 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3598 #ifdef HARD_MALLOC_TESTS
3599 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3600 void *nmem
= realloc(real_ptr
, size
+ 8);
3605 ret
= (void*)((caddr_t
)nmem
+ 8);
3611 return realloc(mem
, size
);
3616 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3618 #ifdef HARD_MALLOC_TESTS
3619 void *mem
= my_malloc(ptr
, nelem
* size
);
3622 memset(mem
, 0, nelem
* size
);
3628 return calloc(nelem
, size
);
3632 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3634 memcached_return_t rc
;
3635 const char *key
= "mine";
3638 /* Make sure be default none exists */
3639 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3641 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3643 /* Test a clean set */
3644 test_compare(MEMCACHED_SUCCESS
,
3645 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3647 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3649 test_memcmp(value
, key
, 4);
3650 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3652 /* Test that we can turn it off */
3653 test_compare(MEMCACHED_SUCCESS
,
3654 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3656 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3658 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3660 /* Now setup for main test */
3661 test_compare(MEMCACHED_SUCCESS
,
3662 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3664 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3666 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3667 test_memcmp(value
, key
, 4);
3669 /* Set to Zero, and then Set to something too large */
3672 memset(long_key
, 0, 255);
3674 test_compare(MEMCACHED_SUCCESS
,
3675 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3677 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3679 test_compare(MEMCACHED_SUCCESS
, rc
);
3681 /* Test a long key for failure */
3682 /* TODO, extend test to determine based on setting, what result should be */
3683 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3684 test_compare(MEMCACHED_SUCCESS
,
3685 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3687 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3688 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3689 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3690 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3692 /* Test for a bad prefix, but with a short key */
3693 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3694 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3696 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3697 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3700 return TEST_SUCCESS
;
3703 static test_return_t
set_namespace(memcached_st
*memc
)
3705 memcached_return_t rc
;
3706 const char *key
= "mine";
3709 // Make sure we default to a null namespace
3710 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3712 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3714 /* Test a clean set */
3715 test_compare(MEMCACHED_SUCCESS
,
3716 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3718 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3720 test_memcmp(value
, key
, 4);
3721 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3723 return TEST_SUCCESS
;
3726 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3728 test_return_if(pre_binary(memc
));
3729 test_return_if(set_namespace(memc
));
3731 return TEST_SUCCESS
;
3734 #ifdef MEMCACHED_ENABLE_DEPRECATED
3735 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3737 void *test_ptr
= NULL
;
3740 memcached_malloc_fn malloc_cb
=
3741 (memcached_malloc_fn
)my_malloc
;
3742 cb_ptr
= *(void **)&malloc_cb
;
3743 memcached_return_t rc
;
3745 test_compare(MEMCACHED_SUCCESS
,
3746 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3747 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3748 test_compare(MEMCACHED_SUCCESS
, rc
);
3749 test_true(test_ptr
== cb_ptr
);
3753 memcached_realloc_fn realloc_cb
=
3754 (memcached_realloc_fn
)my_realloc
;
3755 cb_ptr
= *(void **)&realloc_cb
;
3756 memcached_return_t rc
;
3758 test_compare(MEMCACHED_SUCCESS
,
3759 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3760 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3761 test_compare(MEMCACHED_SUCCESS
, rc
);
3762 test_true(test_ptr
== cb_ptr
);
3766 memcached_free_fn free_cb
=
3767 (memcached_free_fn
)my_free
;
3768 cb_ptr
= *(void **)&free_cb
;
3769 memcached_return_t rc
;
3771 test_compare(MEMCACHED_SUCCESS
,
3772 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3773 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3774 test_compare(MEMCACHED_SUCCESS
, rc
);
3775 test_true(test_ptr
== cb_ptr
);
3778 return TEST_SUCCESS
;
3783 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3785 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3786 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3787 my_realloc
, my_calloc
, NULL
));
3789 test_compare(MEMCACHED_SUCCESS
,
3790 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3791 my_realloc
, my_calloc
, NULL
));
3793 memcached_malloc_fn mem_malloc
;
3794 memcached_free_fn mem_free
;
3795 memcached_realloc_fn mem_realloc
;
3796 memcached_calloc_fn mem_calloc
;
3797 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3798 &mem_realloc
, &mem_calloc
);
3800 test_true(mem_malloc
== my_malloc
);
3801 test_true(mem_realloc
== my_realloc
);
3802 test_true(mem_calloc
== my_calloc
);
3803 test_true(mem_free
== my_free
);
3805 return TEST_SUCCESS
;
3808 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3811 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3812 memcached_hash_t hash
;
3813 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3814 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3817 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3818 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3820 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3822 if (hash
!= MEMCACHED_HASH_CRC
)
3823 return TEST_SKIPPED
;
3825 return TEST_SUCCESS
;
3828 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3831 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3832 memcached_hash_t hash
;
3833 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3834 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3839 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3840 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3842 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3844 if (hash
!= MEMCACHED_HASH_HSIEH
)
3845 return TEST_SKIPPED
;
3848 return TEST_SUCCESS
;
3851 static test_return_t
enable_cas(memcached_st
*memc
)
3853 unsigned int set
= 1;
3855 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3857 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3859 return TEST_SUCCESS
;
3862 return TEST_SKIPPED
;
3865 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3867 memcached_version(memc
);
3869 memcached_server_instance_st instance
=
3870 memcached_server_instance_by_position(memc
, 0);
3872 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3873 or instance
->minor_version
> 2)
3875 return TEST_SUCCESS
;
3878 return TEST_SKIPPED
;
3881 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3885 memcached_servers_reset(memc
);
3886 const char *socket_file
= default_socket();
3888 test_skip(0, stat(socket_file
, &buf
));
3890 test_compare(MEMCACHED_SUCCESS
,
3891 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
3893 return TEST_SUCCESS
;
3896 static test_return_t
pre_nodelay(memcached_st
*memc
)
3898 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3899 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3901 return TEST_SUCCESS
;
3904 static test_return_t
pre_settimer(memcached_st
*memc
)
3906 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3907 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3909 return TEST_SUCCESS
;
3912 static test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3914 const uint64_t timeout
= 100; // Not using, just checking that it sets
3916 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3918 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3920 return TEST_SUCCESS
;
3923 static test_return_t
noreply_test(memcached_st
*memc
)
3925 test_compare(MEMCACHED_SUCCESS
,
3926 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
3927 test_compare(MEMCACHED_SUCCESS
,
3928 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1));
3929 test_compare(MEMCACHED_SUCCESS
,
3930 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
3931 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3932 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3933 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3935 memcached_return_t ret
;
3936 for (int count
= 0; count
< 5; ++count
)
3938 for (size_t x
= 0; x
< 100; ++x
)
3941 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3942 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3944 size_t len
= (size_t)check_length
;
3949 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3952 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3955 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3958 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3961 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3967 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, ret
));
3971 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3972 ** API and is _ONLY_ done this way to verify that the library works the
3973 ** way it is supposed to do!!!!
3976 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3978 memcached_server_instance_st instance
=
3979 memcached_server_instance_by_position(memc
, x
);
3980 no_msg
+=(int)(instance
->cursor_active
);
3983 test_true(no_msg
== 0);
3984 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3987 ** Now validate that all items was set properly!
3989 for (size_t x
= 0; x
< 100; ++x
)
3993 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3995 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3997 size_t len
= (size_t)check_length
;
4000 char* value
=memcached_get(memc
, key
, strlen(key
),
4001 &length
, &flags
, &ret
);
4002 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
4005 case 0: /* FALLTHROUGH */
4006 case 1: /* FALLTHROUGH */
4008 test_true(strncmp(value
, key
, len
) == 0);
4009 test_true(len
== length
);
4012 test_true(length
== len
* 2);
4015 test_true(length
== len
* 3);
4025 /* Try setting an illegal cas value (should not return an error to
4026 * the caller (because we don't expect a return message from the server)
4028 const char* keys
[]= {"0"};
4029 size_t lengths
[]= {1};
4032 memcached_result_st results_obj
;
4033 memcached_result_st
*results
;
4034 test_compare(MEMCACHED_SUCCESS
,
4035 memcached_mget(memc
, keys
, lengths
, 1));
4037 results
= memcached_result_create(memc
, &results_obj
);
4039 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4041 test_compare(MEMCACHED_SUCCESS
, ret
);
4042 uint64_t cas
= memcached_result_cas(results
);
4043 memcached_result_free(&results_obj
);
4045 test_compare(MEMCACHED_SUCCESS
,
4046 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4049 * The item will have a new cas value, so try to set it again with the old
4050 * value. This should fail!
4052 test_compare(MEMCACHED_SUCCESS
,
4053 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4054 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4055 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4056 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4059 return TEST_SUCCESS
;
4062 static test_return_t
analyzer_test(memcached_st
*memc
)
4064 memcached_return_t rc
;
4065 memcached_analysis_st
*report
;
4067 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4068 test_compare(MEMCACHED_SUCCESS
, rc
);
4069 test_true(memc_stat
);
4071 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4072 test_compare(MEMCACHED_SUCCESS
, rc
);
4076 memcached_stat_free(NULL
, memc_stat
);
4078 return TEST_SUCCESS
;
4081 /* Count the objects */
4083 static test_return_t
dump_test(memcached_st
*memc
)
4085 /* No support for Binary protocol yet */
4086 test_skip(false, memc
->flags
.binary_protocol
);
4088 test_compare(TEST_SUCCESS
, set_test3(memc
));
4090 // confirm_key_count() call dump
4091 size_t counter
= confirm_key_count(memc
);
4093 /* We may have more then 32 if our previous flush has not completed */
4094 test_true(counter
>= 32);
4096 return TEST_SUCCESS
;
4099 static test_return_t
util_version_test(memcached_st
*memc
)
4101 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
4102 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
4104 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4106 // We expect failure
4109 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4110 fprintf(stderr
, "\nDumping Server Information\n\n");
4111 memcached_server_fn callbacks
[1];
4113 callbacks
[0]= dump_server_information
;
4114 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4115 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4117 test_true(if_successful
== false);
4119 memcached_server_instance_st instance
=
4120 memcached_server_instance_by_position(memc
, 0);
4122 memcached_version(memc
);
4124 // We only use one binary when we test, so this should be just fine.
4125 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4126 test_true(if_successful
== true);
4128 if (instance
->micro_version
> 0)
4130 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4132 else if (instance
->minor_version
> 0)
4134 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4136 else if (instance
->major_version
> 0)
4138 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4141 test_true(if_successful
== true);
4143 if (instance
->micro_version
> 0)
4145 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4147 else if (instance
->minor_version
> 0)
4149 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4151 else if (instance
->major_version
> 0)
4153 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4156 test_true(if_successful
== false);
4158 return TEST_SUCCESS
;
4161 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4163 memcached_return_t rc
;
4164 memcached_server_instance_st instance
=
4165 memcached_server_instance_by_position(memc
, 0);
4167 // Test both the version that returns a code, and the one that does not.
4168 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4169 memcached_server_port(instance
) -1, NULL
) == -1);
4171 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4172 memcached_server_port(instance
) -1, &rc
) == -1);
4173 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4175 return TEST_SUCCESS
;
4179 static test_return_t
getpid_test(memcached_st
*memc
)
4181 memcached_return_t rc
;
4182 memcached_server_instance_st instance
=
4183 memcached_server_instance_by_position(memc
, 0);
4185 // Test both the version that returns a code, and the one that does not.
4186 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4187 memcached_server_port(instance
), NULL
) > -1);
4189 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4190 memcached_server_port(instance
), &rc
) > -1);
4191 test_compare(MEMCACHED_SUCCESS
, rc
);
4193 return TEST_SUCCESS
;
4196 static test_return_t
ping_test(memcached_st
*memc
)
4198 memcached_return_t rc
;
4199 memcached_server_instance_st instance
=
4200 memcached_server_instance_by_position(memc
, 0);
4202 // Test both the version that returns a code, and the one that does not.
4203 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4204 memcached_server_port(instance
), NULL
));
4206 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4207 memcached_server_port(instance
), &rc
));
4209 test_compare(MEMCACHED_SUCCESS
, rc
);
4211 return TEST_SUCCESS
;
4216 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4220 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4221 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4222 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4223 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4224 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4225 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4226 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4227 #ifdef HAVE_HSIEH_HASH
4228 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4230 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4231 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4232 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4234 return TEST_SUCCESS
;
4238 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4240 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4242 test_compare(MEMCACHED_SUCCESS
,
4243 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4244 (uint64_t)MEMCACHED_HASH_HSIEH
));
4246 return TEST_SUCCESS
;
4249 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4251 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4253 test_compare(MEMCACHED_SUCCESS
,
4254 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
4256 return TEST_SUCCESS
;
4259 static test_return_t
one_at_a_time_run (memcached_st
*)
4264 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4266 test_compare(one_at_a_time_values
[x
],
4267 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
4270 return TEST_SUCCESS
;
4273 static test_return_t
md5_run (memcached_st
*)
4278 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4280 test_compare(md5_values
[x
],
4281 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
4284 return TEST_SUCCESS
;
4287 static test_return_t
crc_run (memcached_st
*)
4292 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4294 test_compare(crc_values
[x
],
4295 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
4298 return TEST_SUCCESS
;
4301 static test_return_t
fnv1_64_run (memcached_st
*)
4303 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
4308 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4310 test_compare(fnv1_64_values
[x
],
4311 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
4314 return TEST_SUCCESS
;
4317 static test_return_t
fnv1a_64_run (memcached_st
*)
4319 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
4324 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4326 test_compare(fnv1a_64_values
[x
],
4327 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
4330 return TEST_SUCCESS
;
4333 static test_return_t
fnv1_32_run (memcached_st
*)
4338 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4340 test_compare(fnv1_32_values
[x
],
4341 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
4344 return TEST_SUCCESS
;
4347 static test_return_t
fnv1a_32_run (memcached_st
*)
4352 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4354 test_compare(fnv1a_32_values
[x
],
4355 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
4358 return TEST_SUCCESS
;
4361 static test_return_t
hsieh_run (memcached_st
*)
4363 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4368 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4370 test_compare(hsieh_values
[x
],
4371 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
4374 return TEST_SUCCESS
;
4377 static test_return_t
murmur_run (memcached_st
*)
4379 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4381 #ifdef WORDS_BIGENDIAN
4382 (void)murmur_values
;
4383 return TEST_SKIPPED
;
4388 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4390 test_compare(murmur_values
[x
],
4391 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
4394 return TEST_SUCCESS
;
4398 static test_return_t
jenkins_run (memcached_st
*)
4403 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4405 test_compare(jenkins_values
[x
],
4406 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
4409 return TEST_SUCCESS
;
4412 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
4414 return libhashkit_md5(string
, string_length
);
4417 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
4419 return libhashkit_crc32(string
, string_length
);
4422 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4428 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5"));
4430 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};
4431 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};
4433 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4435 hashkit_clone(&new_kit
, kit
);
4436 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4438 memcached_set_hashkit(memc
, &new_kit
);
4441 Verify Setting the hash.
4443 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4447 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4448 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4453 Now check memcached_st.
4455 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4459 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4460 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4463 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4465 memcached_set_hashkit(memc
, &new_kit
);
4468 Verify Setting the hash.
4470 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4474 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4475 test_true(crc_values
[x
] == hash_val
);
4478 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4482 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4483 test_compare(crc_hosts
[x
], hash_val
);
4486 memcached_free(memc
);
4488 return TEST_SUCCESS
;
4492 Test case adapted from John Gorman <johngorman2@gmail.com>
4494 We are testing the error condition when we connect to a server via memcached_get()
4495 but find that the server is not available.
4497 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4499 const char *key
= "MemcachedLives";
4502 memcached_return rc
;
4505 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4507 // See if memcached is reachable.
4508 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4512 test_true(memcached_failed(rc
));
4514 memcached_free(tl_memc_h
);
4516 return TEST_SUCCESS
;
4520 We connect to a server which exists, but search for a key that does not exist.
4522 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4524 const char *key
= "MemcachedKeyNotEXIST";
4527 memcached_return rc
;
4529 // See if memcached is reachable.
4530 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4534 test_compare(MEMCACHED_NOTFOUND
, rc
);
4536 return TEST_SUCCESS
;
4540 Test case adapted from John Gorman <johngorman2@gmail.com>
4542 We are testing the error condition when we connect to a server via memcached_get_by_key()
4543 but find that the server is not available.
4545 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4548 memcached_st
*tl_memc_h
;
4549 memcached_server_st
*servers
;
4551 const char *key
= "MemcachedLives";
4554 memcached_return rc
;
4558 tl_memc_h
= memcached_create(NULL
);
4559 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4560 memcached_server_push(tl_memc_h
, servers
);
4561 memcached_server_list_free(servers
);
4563 // See if memcached is reachable.
4564 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4568 test_true(memcached_failed(rc
));
4570 memcached_free(tl_memc_h
);
4572 return TEST_SUCCESS
;
4576 We connect to a server which exists, but search for a key that does not exist.
4578 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4580 const char *key
= "MemcachedKeyNotEXIST";
4583 memcached_return rc
;
4586 // See if memcached is reachable.
4587 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4591 test_compare(MEMCACHED_NOTFOUND
, rc
);
4593 return TEST_SUCCESS
;
4596 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4598 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4600 const char *key
= "regression_bug_434484";
4601 size_t keylen
= strlen(key
);
4603 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4604 test_compare(MEMCACHED_NOTSTORED
, ret
);
4606 size_t size
= 2048 * 1024;
4607 char *data
= (char*)calloc(1, size
);
4609 test_compare(MEMCACHED_E2BIG
,
4610 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4613 return TEST_SUCCESS
;
4616 static test_return_t
regression_bug_434843(memcached_st
*memc
)
4618 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4620 memcached_return_t rc
;
4622 memcached_execute_fn callbacks
[]= { &callback_counter
};
4625 * I only want to hit only _one_ server so I know the number of requests I'm
4626 * sending in the pipleine to the server. Let's try to do a multiget of
4627 * 1024 (that should satisfy most users don't you think?). Future versions
4628 * will include a mget_execute function call if you need a higher number.
4630 uint32_t number_of_hosts
= memcached_server_count(memc
);
4631 memc
->number_of_hosts
= 1;
4632 const size_t max_keys
= 1024;
4633 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4634 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4636 for (size_t x
= 0; x
< max_keys
; ++x
)
4640 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4646 * Run two times.. the first time we should have 100% cache miss,
4647 * and the second time we should have 100% cache hits
4649 for (size_t y
= 0; y
< 2; y
++)
4651 test_compare(MEMCACHED_SUCCESS
,
4652 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4654 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4655 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4659 /* The first iteration should give me a 100% cache miss. verify that*/
4660 char blob
[1024]= { 0 };
4662 test_false(counter
);
4664 for (size_t x
= 0; x
< max_keys
; ++x
)
4666 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4667 blob
, sizeof(blob
), 0, 0);
4668 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4673 /* Verify that we received all of the key/value pairs */
4674 test_compare(counter
, max_keys
);
4678 /* Release allocated resources */
4679 for (size_t x
= 0; x
< max_keys
; ++x
)
4686 memc
->number_of_hosts
= number_of_hosts
;
4688 return TEST_SUCCESS
;
4691 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4693 memcached_return_t rc
;
4694 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4695 test_compare(MEMCACHED_SUCCESS
, rc
);
4697 return regression_bug_434843(memc
);
4700 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4702 memcached_return_t rc
;
4703 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4704 test_compare(MEMCACHED_SUCCESS
, rc
);
4706 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4707 test_compare(MEMCACHED_SUCCESS
, rc
);
4708 test_true(bytes_str
);
4709 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4711 test_compare(MEMCACHED_SUCCESS
, rc
);
4712 test_true(bytes_read_str
);
4714 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4715 "bytes_written", &rc
);
4716 test_compare(MEMCACHED_SUCCESS
, rc
);
4717 test_true(bytes_written_str
);
4719 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4720 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4721 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4723 test_true(bytes
!= bytes_read
);
4724 test_true(bytes
!= bytes_written
);
4726 /* Release allocated resources */
4728 free(bytes_read_str
);
4729 free(bytes_written_str
);
4730 memcached_stat_free(NULL
, memc_stat
);
4732 return TEST_SUCCESS
;
4736 * The test case isn't obvious so I should probably document why
4737 * it works the way it does. Bug 442914 was caused by a bug
4738 * in the logic in memcached_purge (it did not handle the case
4739 * where the number of bytes sent was equal to the watermark).
4740 * In this test case, create messages so that we hit that case
4741 * and then disable noreply mode and issue a new command to
4742 * verify that it isn't stuck. If we change the format for the
4743 * delete command or the watermarks, we need to update this
4746 static test_return_t
regression_bug_442914(memcached_st
*memc
)
4748 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4749 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4751 uint32_t number_of_hosts
= memcached_server_count(memc
);
4752 memc
->number_of_hosts
= 1;
4757 for (uint32_t x
= 0; x
< 250; ++x
)
4759 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4760 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4761 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4764 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
4767 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4768 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4770 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4771 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
4773 memc
->number_of_hosts
= number_of_hosts
;
4775 return TEST_SUCCESS
;
4778 static test_return_t
regression_bug_447342(memcached_st
*memc
)
4780 memcached_server_instance_st instance_one
;
4781 memcached_server_instance_st instance_two
;
4783 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4784 return TEST_SKIPPED
;
4786 test_compare(MEMCACHED_SUCCESS
,
4787 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4789 const unsigned int max_keys
= 100;
4790 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4791 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4793 for (unsigned int x
= 0; x
< max_keys
; ++x
)
4797 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4800 test_compare(MEMCACHED_SUCCESS
,
4801 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
4805 ** We are using the quiet commands to store the replicas, so we need
4806 ** to ensure that all of them are processed before we can continue.
4807 ** In the test we go directly from storing the object to trying to
4808 ** receive the object from all of the different servers, so we
4809 ** could end up in a race condition (the memcached server hasn't yet
4810 ** processed the quiet command from the replication set when it process
4811 ** the request from the other client (created by the clone)). As a
4812 ** workaround for that we call memcached_quit to send the quit command
4813 ** to the server and wait for the response ;-) If you use the test code
4814 ** as an example for your own code, please note that you shouldn't need
4817 memcached_quit(memc
);
4819 /* Verify that all messages are stored, and we didn't stuff too much
4822 test_compare(MEMCACHED_SUCCESS
,
4823 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4825 unsigned int counter
= 0;
4826 memcached_execute_fn callbacks
[]= { &callback_counter
};
4827 test_compare(MEMCACHED_SUCCESS
,
4828 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4830 /* Verify that we received all of the key/value pairs */
4831 test_compare(counter
, max_keys
);
4833 memcached_quit(memc
);
4835 * Don't do the following in your code. I am abusing the internal details
4836 * within the library, and this is not a supported interface.
4837 * This is to verify correct behavior in the library. Fake that two servers
4840 instance_one
= memcached_server_instance_by_position(memc
, 0);
4841 instance_two
= memcached_server_instance_by_position(memc
, 2);
4842 in_port_t port0
= instance_one
->port
;
4843 in_port_t port2
= instance_two
->port
;
4845 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4846 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4848 test_compare(MEMCACHED_SUCCESS
,
4849 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4852 test_compare(MEMCACHED_SUCCESS
,
4853 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4854 test_compare(counter
, (unsigned int)max_keys
);
4856 /* restore the memc handle */
4857 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4858 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4860 memcached_quit(memc
);
4862 /* Remove half of the objects */
4863 for (size_t x
= 0; x
< max_keys
; ++x
)
4867 test_compare(MEMCACHED_SUCCESS
,
4868 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
4872 memcached_quit(memc
);
4873 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4874 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4876 /* now retry the command, this time we should have cache misses */
4877 test_compare(MEMCACHED_SUCCESS
,
4878 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4881 test_compare(MEMCACHED_SUCCESS
,
4882 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4883 test_compare(counter
, (unsigned int)(max_keys
>> 1));
4885 /* Release allocated resources */
4886 for (size_t x
= 0; x
< max_keys
; ++x
)
4893 /* restore the memc handle */
4894 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4895 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4897 return TEST_SUCCESS
;
4900 static test_return_t
regression_bug_463297(memcached_st
*memc
)
4902 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4903 test_true(memc_clone
);
4904 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4906 memcached_server_instance_st instance
=
4907 memcached_server_instance_by_position(memc_clone
, 0);
4909 if (instance
->major_version
> 1 ||
4910 (instance
->major_version
== 1 &&
4911 instance
->minor_version
> 2))
4913 /* Binary protocol doesn't support deferred delete */
4914 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4915 test_true(bin_clone
);
4916 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4917 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4918 memcached_free(bin_clone
);
4920 memcached_quit(memc_clone
);
4922 /* If we know the server version, deferred delete should fail
4923 * with invalid arguments */
4924 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4926 /* If we don't know the server version, we should get a protocol error */
4927 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4929 /* but there is a bug in some of the memcached servers (1.4) that treats
4930 * the counter as noreply so it doesn't send the proper error message
4932 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4934 /* And buffered mode should be disabled and we should get protocol error */
4935 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4936 rc
= memcached_delete(memc
, "foo", 3, 1);
4937 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4939 /* Same goes for noreply... */
4940 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4941 rc
= memcached_delete(memc
, "foo", 3, 1);
4942 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4944 /* but a normal request should go through (and be buffered) */
4945 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4946 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4948 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4949 /* unbuffered noreply should be success */
4950 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4951 /* unbuffered with reply should be not found... */
4952 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4953 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4956 memcached_free(memc_clone
);
4957 return TEST_SUCCESS
;
4961 /* Test memcached_server_get_last_disconnect
4962 * For a working server set, shall be NULL
4963 * For a set of non existing server, shall not be NULL
4965 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4967 memcached_return_t rc
;
4968 memcached_server_instance_st disconnected_server
;
4970 /* With the working set of server */
4971 const char *key
= "marmotte";
4972 const char *value
= "milka";
4974 memcached_reset_last_disconnected_server(memc
);
4975 test_false(memc
->last_disconnected_server
);
4976 rc
= memcached_set(memc
, key
, strlen(key
),
4977 value
, strlen(value
),
4978 (time_t)0, (uint32_t)0);
4979 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4981 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4982 test_false(disconnected_server
);
4984 /* With a non existing server */
4986 memcached_server_st
*servers
;
4988 const char *server_list
= "localhost:9";
4990 servers
= memcached_servers_parse(server_list
);
4992 mine
= memcached_create(NULL
);
4993 rc
= memcached_server_push(mine
, servers
);
4994 test_compare(MEMCACHED_SUCCESS
, rc
);
4995 memcached_server_list_free(servers
);
4998 rc
= memcached_set(mine
, key
, strlen(key
),
4999 value
, strlen(value
),
5000 (time_t)0, (uint32_t)0);
5001 test_true(memcached_failed(rc
));
5003 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5004 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5005 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5006 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5008 memcached_quit(mine
);
5009 memcached_free(mine
);
5011 return TEST_SUCCESS
;
5014 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5016 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5017 char buffer
[BUFSIZ
];
5019 test_compare(MEMCACHED_SUCCESS
,
5020 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5022 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5025 // We will just use the error strings as our keys
5026 uint32_t counter
= 100;
5029 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5031 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5032 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5033 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
5035 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5036 test_true(disconnected_server
);
5037 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5038 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5042 memcached_reset_last_disconnected_server(memc
);
5047 memcached_free(memc
);
5049 return TEST_SUCCESS
;
5052 static test_return_t
test_verbosity(memcached_st
*memc
)
5054 memcached_verbosity(memc
, 3);
5056 return TEST_SUCCESS
;
5060 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5061 const char *key
, size_t key_length
,
5062 const char *value
, size_t value_length
,
5072 return MEMCACHED_SUCCESS
;
5075 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5077 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5078 test_compare(MEMCACHED_SUCCESS
, rc
);
5080 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5081 test_compare(MEMCACHED_SUCCESS
, rc
);
5083 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5084 test_compare(MEMCACHED_SUCCESS
, rc
);
5086 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5087 test_compare(MEMCACHED_SUCCESS
, rc
);
5089 return TEST_SUCCESS
;
5093 * This test ensures that the failure counter isn't incremented during
5094 * normal termination of the memcached instance.
5096 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5098 memcached_return_t rc
;
5099 memcached_server_instance_st instance
;
5101 /* Set value to force connection to the server */
5102 const char *key
= "marmotte";
5103 const char *value
= "milka";
5106 * Please note that I'm abusing the internal structures in libmemcached
5107 * in a non-portable way and you shouldn't be doing this. I'm only
5108 * doing this in order to verify that the library works the way it should
5110 uint32_t number_of_hosts
= memcached_server_count(memc
);
5111 memc
->number_of_hosts
= 1;
5113 /* Ensure that we are connected to the server by setting a value */
5114 rc
= memcached_set(memc
, key
, strlen(key
),
5115 value
, strlen(value
),
5116 (time_t)0, (uint32_t)0);
5117 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5120 instance
= memcached_server_instance_by_position(memc
, 0);
5121 /* The test is to see that the memcached_quit doesn't increase the
5122 * the server failure conter, so let's ensure that it is zero
5123 * before sending quit
5125 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5127 memcached_quit(memc
);
5129 /* Verify that it memcached_quit didn't increment the failure counter
5130 * Please note that this isn't bullet proof, because an error could
5133 test_zero(instance
->server_failure_counter
);
5135 /* restore the instance */
5136 memc
->number_of_hosts
= number_of_hosts
;
5138 return TEST_SUCCESS
;
5142 * This tests ensures expected disconnections (for some behavior changes
5143 * for instance) do not wrongly increase failure counter
5145 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5147 memcached_return rc
;
5149 memcached_st
*memc_clone
;
5150 memc_clone
= memcached_clone(NULL
, memc
);
5151 test_true(memc_clone
);
5153 /* Set value to force connection to the server */
5154 const char *key
= "marmotte";
5155 const char *value
= "milka";
5156 char *string
= NULL
;
5157 size_t string_length
;
5160 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5161 value
, strlen(value
),
5162 (time_t)0, (uint32_t)0);
5163 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5166 /* put failure limit to 1 */
5167 test_compare(MEMCACHED_SUCCESS
,
5168 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1));
5170 /* Put a retry timeout to effectively activate failure_limit effect */
5171 test_compare(MEMCACHED_SUCCESS
,
5172 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
5174 /* change behavior that triggers memcached_quit()*/
5175 test_compare(MEMCACHED_SUCCESS
,
5176 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5179 /* Check if we still are connected */
5180 string
= memcached_get(memc_clone
, key
, strlen(key
),
5181 &string_length
, &flags
, &rc
);
5183 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5186 memcached_free(memc_clone
);
5188 return TEST_SUCCESS
;
5195 * Test that ensures mget_execute does not end into recursive calls that finally fails
5197 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5199 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5200 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5201 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5202 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5203 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5206 return TEST_SKIPPED
; // My MAC can't handle this test
5210 * I only want to hit _one_ server so I know the number of requests I'm
5211 * sending in the pipeline.
5213 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5214 memc
->number_of_hosts
= 1;
5215 size_t max_keys
= 20480;
5218 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5219 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5221 /* First add all of the items.. */
5222 char blob
[1024]= { 0 };
5223 for (size_t x
= 0; x
< max_keys
; ++x
)
5226 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5229 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5230 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5235 /* Try to get all of them with a large multiget */
5237 memcached_execute_function callbacks
[]= { &callback_counter
};
5238 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5239 (size_t)max_keys
, callbacks
, &counter
, 1);
5240 test_compare(MEMCACHED_SUCCESS
, rc
);
5242 char* the_value
= NULL
;
5243 char the_key
[MEMCACHED_MAX_KEY
];
5244 size_t the_key_length
;
5245 size_t the_value_length
;
5249 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5251 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5257 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5260 test_compare(MEMCACHED_END
, rc
);
5262 /* Verify that we got all of the items */
5263 test_compare(counter
, max_keys
);
5266 /* Release all allocated resources */
5267 for (size_t x
= 0; x
< max_keys
; ++x
)
5274 memc
->number_of_hosts
= number_of_hosts
;
5276 return TEST_SUCCESS
;
5279 static test_return_t
regression_bug_583031(memcached_st
*)
5281 memcached_st
*memc
= memcached_create(NULL
);
5283 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5285 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5286 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5287 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5288 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5289 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5290 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5292 memcached_return_t rc
;
5296 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5300 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5302 memcached_free(memc
);
5304 return TEST_SUCCESS
;
5307 static test_return_t
regression_bug_581030(memcached_st
*)
5310 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5311 test_false(local_stat
);
5313 memcached_stat_free(NULL
, NULL
);
5316 return TEST_SUCCESS
;
5319 #define regression_bug_655423_COUNT 6000
5320 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5322 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5323 memc
= NULL
; // Just to make sure it is not used
5328 return TEST_SKIPPED
;
5331 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5332 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5333 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5334 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5336 memset(payload
, int('x'), sizeof(payload
));
5338 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5340 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5341 snprintf(key
, sizeof(key
), "%u", x
);
5343 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5346 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5348 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5349 snprintf(key
, sizeof(key
), "%u", x
);
5351 size_t value_length
;
5352 memcached_return_t rc
;
5353 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5355 if (rc
== MEMCACHED_NOTFOUND
)
5358 test_zero(value_length
);
5362 test_compare(MEMCACHED_SUCCESS
, rc
);
5364 test_compare(100LLU, value_length
);
5368 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5369 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5370 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5372 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5373 snprintf(key
, sizeof(key
), "%u", x
);
5375 keys
[x
]= strdup(key
);
5377 key_length
[x
]= strlen(key
);
5378 test_true(key_length
[x
]);
5381 test_compare(MEMCACHED_SUCCESS
,
5382 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5385 memcached_result_st
*result
= NULL
;
5386 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5388 test_compare(size_t(100), memcached_result_length(result
));
5392 test_true(count
> 100); // If we don't get back atleast this, something is up
5394 /* Release all allocated resources */
5395 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5403 memcached_free(clone
);
5405 return TEST_SUCCESS
;
5409 * Test that ensures that buffered set to not trigger problems during io_flush
5411 #define regression_bug_490520_COUNT 200480
5412 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5414 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5415 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5416 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5417 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5418 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5420 memc
->number_of_hosts
= 1;
5422 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5423 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5425 /* First add all of the items.. */
5426 char blob
[3333] = {0};
5427 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5430 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5434 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5435 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5438 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5445 return TEST_SUCCESS
;
5449 static test_return_t
regression_bug_854604(memcached_st
*)
5453 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
5455 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
5457 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
5458 test_compare(buffer
[0], 0);
5460 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
5461 test_true(strlen(buffer
));
5463 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
5464 test_true(strlen(buffer
));
5466 return TEST_SUCCESS
;
5469 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5471 fprintf(stderr
, "Iteration #%u: ", it
);
5473 if (error
== MEMCACHED_ERRNO
)
5475 fprintf(stderr
, "system error %d from %s: %s\n",
5476 errno
, what
, strerror(errno
));
5480 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5481 memcached_strerror(mc
, error
));
5485 #define TEST_CONSTANT_CREATION 200
5487 static test_return_t
regression_bug_(memcached_st
*memc
)
5489 const char *remote_server
;
5492 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5494 return TEST_SKIPPED
;
5497 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5499 memcached_st
* mc
= memcached_create(NULL
);
5500 memcached_return rc
;
5502 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5503 if (rc
!= MEMCACHED_SUCCESS
)
5505 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5508 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5509 if (rc
!= MEMCACHED_SUCCESS
)
5511 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5514 rc
= memcached_server_add(mc
, remote_server
, 0);
5515 if (rc
!= MEMCACHED_SUCCESS
)
5517 memcached_die(mc
, rc
, "memcached_server_add", x
);
5520 const char *set_key
= "akey";
5521 const size_t set_key_len
= strlen(set_key
);
5522 const char *set_value
= "a value";
5523 const size_t set_value_len
= strlen(set_value
);
5525 if (rc
== MEMCACHED_SUCCESS
)
5529 size_t get_value_len
;
5531 uint32_t get_value_flags
;
5533 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5534 &get_value_flags
, &rc
);
5535 if (rc
!= MEMCACHED_SUCCESS
)
5537 memcached_die(mc
, rc
, "memcached_get", x
);
5543 (get_value_len
!= set_value_len
5544 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5546 fprintf(stderr
, "Values don't match?\n");
5547 rc
= MEMCACHED_FAILURE
;
5553 rc
= memcached_set(mc
,
5554 set_key
, set_key_len
,
5555 set_value
, set_value_len
,
5559 if (rc
!= MEMCACHED_SUCCESS
)
5561 memcached_die(mc
, rc
, "memcached_set", x
);
5568 if (rc
!= MEMCACHED_SUCCESS
)
5574 return TEST_SUCCESS
;
5577 /* Clean the server before beginning testing */
5579 {"util_version", true, (test_callback_fn
*)util_version_test
},
5580 {"flush", false, (test_callback_fn
*)flush_test
},
5581 {"init", false, (test_callback_fn
*)init_test
},
5582 {"allocation", false, (test_callback_fn
*)allocation_test
},
5583 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5584 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5585 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5586 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5587 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5588 {"clone_test", false, (test_callback_fn
*)clone_test
},
5589 {"connection_test", false, (test_callback_fn
*)connection_test
},
5590 {"callback_test", false, (test_callback_fn
*)callback_test
},
5591 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5592 {"set", false, (test_callback_fn
*)set_test
},
5593 {"set2", false, (test_callback_fn
*)set_test2
},
5594 {"set3", false, (test_callback_fn
*)set_test3
},
5595 {"dump", true, (test_callback_fn
*)dump_test
},
5596 {"add", true, (test_callback_fn
*)add_test
},
5597 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5598 {"replace", true, (test_callback_fn
*)replace_test
},
5599 {"delete", true, (test_callback_fn
*)delete_test
},
5600 {"get", true, (test_callback_fn
*)get_test
},
5601 {"get2", false, (test_callback_fn
*)get_test2
},
5602 {"get3", false, (test_callback_fn
*)get_test3
},
5603 {"get4", false, (test_callback_fn
*)get_test4
},
5604 {"partial mget", false, (test_callback_fn
*)get_test5
},
5605 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5606 {"increment", false, (test_callback_fn
*)increment_test
},
5607 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5608 {"decrement", false, (test_callback_fn
*)decrement_test
},
5609 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5610 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5611 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5612 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5613 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5614 {"binary_increment_with_prefix", 1, (test_callback_fn
*)binary_increment_with_prefix_test
},
5615 {"quit", false, (test_callback_fn
*)quit_test
},
5616 {"mget", true, (test_callback_fn
*)mget_test
},
5617 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5618 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5619 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5620 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5621 {"mget_end", false, (test_callback_fn
*)mget_end
},
5622 {"get_stats", false, (test_callback_fn
*)get_stats
},
5623 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5624 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5625 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5626 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
5627 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5628 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5629 {"read_through", true, (test_callback_fn
*)read_through
},
5630 {"delete_through", true, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER
},
5631 {"noreply", true, (test_callback_fn
*)noreply_test
},
5632 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5633 {"memcached_pool_st", true, (test_callback_fn
*)connection_pool_test
},
5634 {"memcached_pool_st #2", true, (test_callback_fn
*)connection_pool2_test
},
5635 {"memcached_pool_st #3", true, (test_callback_fn
*)connection_pool3_test
},
5636 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
5637 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
5638 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
5639 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
5640 {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_NOTFOUND
},
5641 {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_SUCCESS
},
5642 {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_by_key_NOTFOUND
},
5643 {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_by_key_SUCCESS
},
5644 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5645 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5649 test_st touch_tests
[] ={
5650 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5651 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5655 test_st behavior_tests
[] ={
5656 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5657 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5658 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5659 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5660 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5661 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5662 {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test
},
5663 {"MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY", false, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY
},
5667 test_st libmemcachedutil_tests
[] ={
5668 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5669 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5670 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5674 test_st basic_tests
[] ={
5675 {"init", true, (test_callback_fn
*)basic_init_test
},
5676 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5677 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5678 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5679 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5680 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5681 {"memcached_return_t", false, (test_callback_fn
*)memcached_return_t_TEST
},
5685 test_st regression_binary_vs_block
[] ={
5686 {"block add", true, (test_callback_fn
*)block_add_regression
},
5687 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
5691 test_st async_tests
[] ={
5692 {"add", true, (test_callback_fn
*)add_wrapper
},
5696 test_st memcached_server_get_last_disconnect_tests
[] ={
5697 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
5698 {0, 0, (test_callback_fn
*)0}
5702 test_st result_tests
[] ={
5703 {"result static", false, (test_callback_fn
*)result_static
},
5704 {"result alloc", false, (test_callback_fn
*)result_alloc
},
5705 {0, 0, (test_callback_fn
*)0}
5708 test_st version_1_2_3
[] ={
5709 {"append", false, (test_callback_fn
*)append_test
},
5710 {"prepend", false, (test_callback_fn
*)prepend_test
},
5711 {"cas", false, (test_callback_fn
*)cas_test
},
5712 {"cas2", false, (test_callback_fn
*)cas2_test
},
5713 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
5714 {0, 0, (test_callback_fn
*)0}
5717 test_st haldenbrand_tests
[] ={
5718 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
5719 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
5720 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
5721 {0, 0, (test_callback_fn
*)0}
5724 test_st user_tests
[] ={
5725 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
5726 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
5727 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
5728 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
5729 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
5730 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
5731 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
5732 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
5733 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
5734 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
5735 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
5736 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
5737 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
5738 #if !defined(__sun) && !defined(__OpenBSD__)
5740 ** It seems to be something weird with the character sets..
5741 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5742 ** guess I need to find out how this is supposed to work.. Perhaps I need
5743 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5744 ** so just disable the code for now...).
5746 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
5748 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
5749 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
5750 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
5751 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
5752 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
5753 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
5754 {0, 0, (test_callback_fn
*)0}
5757 test_st replication_tests
[]= {
5758 {"set", true, (test_callback_fn
*)replication_set_test
},
5759 {"get", false, (test_callback_fn
*)replication_get_test
},
5760 {"mget", false, (test_callback_fn
*)replication_mget_test
},
5761 {"delete", true, (test_callback_fn
*)replication_delete_test
},
5762 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
5763 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
5764 {0, 0, (test_callback_fn
*)0}
5768 * The following test suite is used to verify that we don't introduce
5769 * regression bugs. If you want more information about the bug / test,
5770 * you should look in the bug report at
5771 * http://bugs.launchpad.net/libmemcached
5773 test_st regression_tests
[]= {
5774 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
5775 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
5776 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
5777 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
5778 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
5779 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
5780 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
5781 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
5782 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
5783 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
5784 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
5785 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
5786 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
5787 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
5788 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
5789 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
5790 {"lp:854604", true, (test_callback_fn
*)regression_bug_854604
},
5791 {0, false, (test_callback_fn
*)0}
5794 test_st ketama_compatibility
[]= {
5795 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
5796 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
5797 {0, 0, (test_callback_fn
*)0}
5800 test_st generate_tests
[] ={
5801 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5802 {"generate_data", true, (test_callback_fn
*)generate_data
},
5803 {"get_read", false, (test_callback_fn
*)get_read
},
5804 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
5805 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5806 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
5807 {"generate_data", true, (test_callback_fn
*)generate_data
},
5808 {"mget_read", false, (test_callback_fn
*)mget_read
},
5809 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
5810 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
5811 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
5812 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
5813 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5814 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
5815 {"generate_data", true, (test_callback_fn
*)generate_data
},
5816 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5817 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5818 {0, 0, (test_callback_fn
*)0}
5821 test_st consistent_tests
[] ={
5822 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5823 {"generate_data", true, (test_callback_fn
*)generate_data
},
5824 {"get_read", 0, (test_callback_fn
*)get_read_count
},
5825 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5826 {0, 0, (test_callback_fn
*)0}
5829 test_st consistent_weighted_tests
[] ={
5830 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5831 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
5832 {"get_read", false, (test_callback_fn
*)get_read_count
},
5833 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5834 {0, 0, (test_callback_fn
*)0}
5837 test_st hsieh_availability
[] ={
5838 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
5839 {0, 0, (test_callback_fn
*)0}
5842 test_st murmur_availability
[] ={
5843 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
5844 {0, 0, (test_callback_fn
*)0}
5848 test_st hash_sanity
[] ={
5849 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
5850 {0, 0, (test_callback_fn
*)0}
5854 test_st ketama_auto_eject_hosts
[] ={
5855 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
5856 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
5857 {0, 0, (test_callback_fn
*)0}
5860 test_st hash_tests
[] ={
5861 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
5862 {"md5", false, (test_callback_fn
*)md5_run
},
5863 {"crc", false, (test_callback_fn
*)crc_run
},
5864 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
5865 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
5866 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
5867 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
5868 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
5869 {"murmur", false, (test_callback_fn
*)murmur_run
},
5870 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
5871 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
5872 {0, 0, (test_callback_fn
*)0}
5875 test_st error_conditions
[] ={
5876 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
5877 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
5878 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
5879 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5880 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5881 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
5882 {0, 0, (test_callback_fn
*)0}
5885 test_st parser_tests
[] ={
5886 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
5887 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
5888 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
5889 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
5890 {"hash", false, (test_callback_fn
*)parser_hash_test
},
5891 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
5892 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
5893 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
5894 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
5895 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
5896 {"server", false, (test_callback_fn
*)server_test
},
5897 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
5898 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
5899 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
5900 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
5901 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
5902 {0, 0, (test_callback_fn
*)0}
5905 test_st virtual_bucket_tests
[] ={
5906 {"basic", false, (test_callback_fn
*)virtual_back_map
},
5907 {0, 0, (test_callback_fn
*)0}
5910 test_st memcached_server_add_tests
[] ={
5911 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
5912 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
5913 {0, 0, (test_callback_fn
*)0}
5916 test_st namespace_tests
[] ={
5917 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
5918 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
5919 {0, 0, (test_callback_fn
*)0}
5922 collection_st collection
[] ={
5924 {"hash_sanity", 0, 0, hash_sanity
},
5926 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
5927 {"basic", 0, 0, basic_tests
},
5928 {"hsieh_availability", 0, 0, hsieh_availability
},
5929 {"murmur_availability", 0, 0, murmur_availability
},
5930 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
5931 {"block", 0, 0, tests
},
5932 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
5933 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
5934 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5935 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
5936 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
5937 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
5938 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
5939 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
5940 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
5941 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
5942 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
5943 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
5944 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
5945 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
5946 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
5947 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5948 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
5949 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
5950 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
5951 #ifdef MEMCACHED_ENABLE_DEPRECATED
5952 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
5954 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
5955 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
5956 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
5957 {"specific namespace", 0, 0, namespace_tests
},
5958 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
5959 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
5960 {"result", 0, 0, result_tests
},
5961 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
5962 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
5963 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
5964 {"user written tests", 0, 0, user_tests
},
5965 {"generate", 0, 0, generate_tests
},
5966 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
5967 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
5968 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
5969 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
5970 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
5971 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
5972 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
5974 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
5975 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
5976 {"consistent_not", 0, 0, consistent_tests
},
5977 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
5978 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
5979 {"ketama_compat", 0, 0, ketama_compatibility
},
5980 {"test_hashes", 0, 0, hash_tests
},
5981 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
5982 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
5983 {"regression", 0, 0, regression_tests
},
5984 {"behaviors", 0, 0, behavior_tests
},
5985 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
5986 {"error_conditions", 0, 0, error_conditions
},
5987 {"parser", 0, 0, parser_tests
},
5988 {"virtual buckets", 0, 0, virtual_bucket_tests
},
5989 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
5990 {"touch", 0, 0, touch_tests
},
5994 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
5996 #include "tests/libmemcached_world.h"
5998 void get_world(Framework
*world
)
6000 world
->collections
= collection
;
6002 world
->_create
= (test_callback_create_fn
*)world_create
;
6003 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6005 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6006 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6007 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6008 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6009 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6011 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6012 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6014 world
->set_runner(&defualt_libmemcached_runner
);
6016 world
->set_socket();