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
.insert(longkey
.end(), MEMCACHED_MAX_KEY
, 'a');
914 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
916 size_t string_length
;
918 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
919 test_compare(MEMCACHED_NOTFOUND
, rc
);
920 test_zero(string_length
);
922 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
923 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
924 test_zero(string_length
);
928 /* Make sure zero length keys are marked as bad */
930 test_compare(MEMCACHED_SUCCESS
,
931 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
932 size_t string_length
;
933 char *string
= memcached_get(memc_clone
, key
, 0,
934 &string_length
, &flags
, &rc
);
935 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
936 test_zero(string_length
);
940 memcached_free(memc_clone
);
945 #define READ_THROUGH_VALUE "set for me"
946 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
949 memcached_result_st
*result
)
951 (void)memc
;(void)key
;(void)key_length
;
952 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
955 #ifndef __INTEL_COMPILER
956 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
959 static test_return_t
read_through(memcached_st
*memc
)
961 memcached_return_t rc
;
962 const char *key
= "foo";
964 size_t string_length
;
966 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
968 string
= memcached_get(memc
, key
, strlen(key
),
969 &string_length
, &flags
, &rc
);
971 test_compare(MEMCACHED_NOTFOUND
, rc
);
972 test_false(string_length
);
975 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
);
976 test_compare(MEMCACHED_SUCCESS
, rc
);
978 string
= memcached_get(memc
, key
, strlen(key
),
979 &string_length
, &flags
, &rc
);
981 test_compare(MEMCACHED_SUCCESS
, rc
);
982 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
983 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
984 test_strcmp(READ_THROUGH_VALUE
, string
);
987 string
= memcached_get(memc
, key
, strlen(key
),
988 &string_length
, &flags
, &rc
);
990 test_compare(MEMCACHED_SUCCESS
, rc
);
992 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
993 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
994 test_strcmp(READ_THROUGH_VALUE
, string
);
1000 static test_return_t
get_test(memcached_st
*memc
)
1002 memcached_return_t rc
;
1003 const char *key
= "foo";
1005 size_t string_length
;
1008 uint64_t query_id
= memcached_query_id(memc
);
1009 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
1010 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
1011 test_compare(query_id
+1, memcached_query_id(memc
));
1013 string
= memcached_get(memc
, key
, strlen(key
),
1014 &string_length
, &flags
, &rc
);
1016 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1017 test_false(string_length
);
1020 return TEST_SUCCESS
;
1023 static test_return_t
get_test2(memcached_st
*memc
)
1025 const char *key
= "foo";
1026 const char *value
= "when we sanitize";
1028 uint64_t query_id
= memcached_query_id(memc
);
1029 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1030 value
, strlen(value
),
1031 (time_t)0, (uint32_t)0);
1032 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1033 test_compare(query_id
+1, memcached_query_id(memc
));
1035 query_id
= memcached_query_id(memc
);
1036 test_true(query_id
);
1039 size_t string_length
;
1040 char *string
= memcached_get(memc
, key
, strlen(key
),
1041 &string_length
, &flags
, &rc
);
1042 test_compare(query_id
+1, memcached_query_id(memc
));
1044 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1045 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1047 test_compare(strlen(value
), string_length
);
1048 test_memcmp(string
, value
, string_length
);
1052 return TEST_SUCCESS
;
1055 static test_return_t
set_test2(memcached_st
*memc
)
1057 const char *key
= "foo";
1058 const char *value
= "train in the brain";
1059 size_t value_length
= strlen(value
);
1061 for (uint32_t x
= 0; x
< 10; x
++)
1063 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1064 value
, value_length
,
1065 (time_t)0, (uint32_t)0);
1066 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1069 return TEST_SUCCESS
;
1072 static test_return_t
set_test3(memcached_st
*memc
)
1074 size_t value_length
= 8191;
1076 char *value
= (char*)malloc(value_length
);
1079 for (uint32_t x
= 0; x
< value_length
; x
++)
1081 value
[x
] = (char) (x
% 127);
1084 /* The dump test relies on there being at least 32 items in memcached */
1085 for (uint32_t x
= 0; x
< 32; x
++)
1089 snprintf(key
, sizeof(key
), "foo%u", x
);
1091 uint64_t query_id
= memcached_query_id(memc
);
1092 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1093 value
, value_length
,
1094 (time_t)0, (uint32_t)0);
1095 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1096 test_compare(query_id
+1, memcached_query_id(memc
));
1101 return TEST_SUCCESS
;
1104 static test_return_t
get_test3(memcached_st
*memc
)
1106 const char *key
= "foo";
1107 size_t value_length
= 8191;
1109 char *value
= (char*)malloc(value_length
);
1112 for (uint32_t x
= 0; x
< value_length
; x
++)
1114 value
[x
] = (char) (x
% 127);
1117 memcached_return_t rc
;
1118 rc
= memcached_set(memc
, key
, strlen(key
),
1119 value
, value_length
,
1120 (time_t)0, (uint32_t)0);
1121 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1123 size_t string_length
;
1125 char *string
= memcached_get(memc
, key
, strlen(key
),
1126 &string_length
, &flags
, &rc
);
1128 test_compare(MEMCACHED_SUCCESS
, rc
);
1130 test_compare(string_length
, value_length
);
1131 test_memcmp(string
, value
, string_length
);
1136 return TEST_SUCCESS
;
1139 static test_return_t
get_test4(memcached_st
*memc
)
1141 const char *key
= "foo";
1142 size_t value_length
= 8191;
1144 char *value
= (char*)malloc(value_length
);
1147 for (uint32_t x
= 0; x
< value_length
; x
++)
1149 value
[x
] = (char) (x
% 127);
1152 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1153 value
, value_length
,
1154 (time_t)0, (uint32_t)0);
1155 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1157 for (uint32_t x
= 0; x
< 10; x
++)
1160 size_t string_length
;
1161 char *string
= memcached_get(memc
, key
, strlen(key
),
1162 &string_length
, &flags
, &rc
);
1164 test_compare(MEMCACHED_SUCCESS
, rc
);
1166 test_compare(string_length
, value_length
);
1167 test_memcmp(string
, value
, string_length
);
1173 return TEST_SUCCESS
;
1177 * This test verifies that memcached_read_one_response doesn't try to
1178 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1179 * responses before you execute a storage command.
1181 static test_return_t
get_test5(memcached_st
*memc
)
1184 ** Request the same key twice, to ensure that we hash to the same server
1185 ** (so that we have multiple response values queued up) ;-)
1187 const char *keys
[]= { "key", "key" };
1188 size_t lengths
[]= { 3, 3 };
1192 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1193 keys
[0], lengths
[0], 0, 0);
1194 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1196 memcached_result_st results_obj
;
1197 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1200 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1203 memcached_result_free(&results_obj
);
1205 /* Don't read out the second result, but issue a set instead.. */
1206 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1208 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1209 &rlen
, &flags
, &rc
);
1211 test_compare(MEMCACHED_NOTFOUND
, rc
);
1212 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1214 test_compare(MEMCACHED_SUCCESS
, rc
);
1217 return TEST_SUCCESS
;
1220 static test_return_t
mget_end(memcached_st
*memc
)
1222 const char *keys
[]= { "foo", "foo2" };
1223 size_t lengths
[]= { 3, 4 };
1224 const char *values
[]= { "fjord", "41" };
1226 memcached_return_t rc
;
1229 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1231 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[x
], lengths
[x
], values
[x
], strlen(values
[x
]), (time_t)0, (uint32_t)0));
1235 size_t string_length
;
1238 // retrieve both via mget
1239 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1241 char key
[MEMCACHED_MAX_KEY
];
1244 // this should get both
1245 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1247 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1249 test_compare(MEMCACHED_SUCCESS
, rc
);
1251 if (key_length
== 4)
1256 test_compare(string_length
, strlen(values
[val
]));
1257 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1261 // this should indicate end
1262 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1263 test_compare(MEMCACHED_END
, rc
);
1267 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1268 test_compare(MEMCACHED_SUCCESS
, rc
);
1270 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1271 test_compare(key_length
, lengths
[0]);
1272 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1273 test_compare(string_length
, strlen(values
[0]));
1274 test_true(strncmp(values
[0], string
, string_length
) == 0);
1275 test_compare(MEMCACHED_SUCCESS
, rc
);
1278 // this should indicate end
1279 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1280 test_compare(MEMCACHED_END
, rc
);
1283 return TEST_SUCCESS
;
1286 /* Do not copy the style of this code, I just access hosts to testthis function */
1287 static test_return_t
stats_servername_test(memcached_st
*memc
)
1289 memcached_stat_st memc_stat
;
1290 memcached_server_instance_st instance
=
1291 memcached_server_instance_by_position(memc
, 0);
1293 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1295 return TEST_SKIPPED
;
1298 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1299 memcached_server_name(instance
),
1300 memcached_server_port(instance
)));
1302 return TEST_SUCCESS
;
1305 static test_return_t
increment_test(memcached_st
*memc
)
1307 uint64_t new_number
;
1309 test_compare(MEMCACHED_SUCCESS
,
1311 test_literal_param("number"),
1312 test_literal_param("0"),
1313 (time_t)0, (uint32_t)0));
1315 test_compare(MEMCACHED_SUCCESS
,
1316 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1317 test_compare(uint64_t(1), new_number
);
1319 test_compare(MEMCACHED_SUCCESS
,
1320 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1321 test_compare(uint64_t(2), new_number
);
1323 return TEST_SUCCESS
;
1326 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1328 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1330 uint64_t new_number
;
1331 uint64_t initial
= 0;
1333 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1335 test_compare(MEMCACHED_SUCCESS
,
1336 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1337 test_compare(new_number
, initial
);
1339 test_compare(MEMCACHED_SUCCESS
,
1340 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1341 test_compare(new_number
, (initial
+1));
1343 return TEST_SUCCESS
;
1346 static test_return_t
decrement_test(memcached_st
*memc
)
1348 uint64_t new_number
;
1349 memcached_return_t rc
;
1350 const char *value
= "3";
1352 rc
= memcached_set(memc
,
1353 test_literal_param("number"),
1354 value
, strlen(value
),
1355 (time_t)0, (uint32_t)0);
1356 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1358 test_compare(MEMCACHED_SUCCESS
,
1359 memcached_decrement(memc
,
1360 test_literal_param("number"),
1362 test_compare(uint64_t(2), new_number
);
1364 test_compare(MEMCACHED_SUCCESS
,
1365 memcached_decrement(memc
,
1366 test_literal_param("number"),
1368 test_compare(uint64_t(1), new_number
);
1370 return TEST_SUCCESS
;
1373 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1375 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1377 uint64_t new_number
;
1378 uint64_t initial
= 3;
1380 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1382 test_compare(MEMCACHED_SUCCESS
,
1383 memcached_decrement_with_initial(memc
,
1384 test_literal_param("number"),
1385 1, initial
, 0, &new_number
));
1386 test_compare(new_number
, initial
);
1388 test_compare(MEMCACHED_SUCCESS
,
1389 memcached_decrement_with_initial(memc
,
1390 test_literal_param("number"),
1391 1, initial
, 0, &new_number
));
1392 test_compare(new_number
, (initial
- 1));
1394 return TEST_SUCCESS
;
1397 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1399 uint64_t new_number
;
1400 memcached_return_t rc
;
1401 const char *master_key
= "foo";
1402 const char *key
= "number";
1403 const char *value
= "0";
1405 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1407 value
, strlen(value
),
1408 (time_t)0, (uint32_t)0);
1409 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1411 test_compare(MEMCACHED_SUCCESS
,
1412 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1413 test_compare(uint64_t(1), new_number
);
1415 test_compare(MEMCACHED_SUCCESS
,
1416 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1417 test_compare(uint64_t(2), new_number
);
1419 return TEST_SUCCESS
;
1422 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1424 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1426 uint64_t new_number
;
1427 memcached_return_t rc
;
1428 const char *master_key
= "foo";
1429 const char *key
= "number";
1430 uint64_t initial
= 0;
1432 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1434 1, initial
, 0, &new_number
);
1435 test_compare(MEMCACHED_SUCCESS
, rc
);
1436 test_compare(new_number
, initial
);
1438 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1440 1, initial
, 0, &new_number
);
1441 test_compare(MEMCACHED_SUCCESS
, rc
);
1442 test_compare(new_number
, (initial
+1));
1444 return TEST_SUCCESS
;
1447 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1449 uint64_t new_number
;
1450 memcached_return_t rc
;
1451 const char *value
= "3";
1453 rc
= memcached_set_by_key(memc
,
1454 test_literal_param("foo"),
1455 test_literal_param("number"),
1456 value
, strlen(value
),
1457 (time_t)0, (uint32_t)0);
1458 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1460 test_compare(MEMCACHED_SUCCESS
,
1461 memcached_decrement_by_key(memc
,
1462 test_literal_param("foo"),
1463 test_literal_param("number"),
1465 test_compare(uint64_t(2), new_number
);
1467 test_compare(MEMCACHED_SUCCESS
,
1468 memcached_decrement_by_key(memc
,
1469 test_literal_param("foo"),
1470 test_literal_param("number"),
1472 test_compare(uint64_t(1), new_number
);
1474 return TEST_SUCCESS
;
1477 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1479 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1481 uint64_t new_number
;
1482 uint64_t initial
= 3;
1484 test_compare(MEMCACHED_SUCCESS
,
1485 memcached_decrement_with_initial_by_key(memc
,
1486 test_literal_param("foo"),
1487 test_literal_param("number"),
1488 1, initial
, 0, &new_number
));
1489 test_compare(new_number
, initial
);
1491 test_compare(MEMCACHED_SUCCESS
,
1492 memcached_decrement_with_initial_by_key(memc
,
1493 test_literal_param("foo"),
1494 test_literal_param("number"),
1495 1, initial
, 0, &new_number
));
1496 test_compare(new_number
, (initial
- 1));
1498 return TEST_SUCCESS
;
1500 static test_return_t
binary_increment_with_prefix_test(memcached_st
*orig_memc
)
1502 memcached_st
*memc
= memcached_clone(NULL
, orig_memc
);
1504 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1506 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1508 memcached_return_t rc
;
1509 rc
= memcached_set(memc
,
1510 test_literal_param("number"),
1511 test_literal_param("0"),
1512 (time_t)0, (uint32_t)0);
1513 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1515 uint64_t new_number
;
1516 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1517 test_literal_param("number"),
1519 test_compare(uint64_t(1), new_number
);
1521 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1522 test_literal_param("number"),
1524 test_compare(uint64_t(2), new_number
);
1525 memcached_free(memc
);
1527 return TEST_SUCCESS
;
1530 static test_return_t
quit_test(memcached_st
*memc
)
1532 memcached_return_t rc
;
1533 const char *key
= "fudge";
1534 const char *value
= "sanford and sun";
1536 rc
= memcached_set(memc
, key
, strlen(key
),
1537 value
, strlen(value
),
1538 (time_t)10, (uint32_t)3);
1539 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1540 memcached_quit(memc
);
1542 rc
= memcached_set(memc
, key
, strlen(key
),
1543 value
, strlen(value
),
1544 (time_t)50, (uint32_t)9);
1545 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1547 return TEST_SUCCESS
;
1550 static test_return_t
mget_result_test(memcached_st
*memc
)
1552 const char *keys
[]= {"fudge", "son", "food"};
1553 size_t key_length
[]= {5, 3, 4};
1555 memcached_result_st results_obj
;
1556 memcached_result_st
*results
;
1558 results
= memcached_result_create(memc
, &results_obj
);
1560 test_true(&results_obj
== results
);
1562 /* We need to empty the server before continueing test */
1563 test_compare(MEMCACHED_SUCCESS
,
1564 memcached_flush(memc
, 0));
1566 test_compare(MEMCACHED_SUCCESS
,
1567 memcached_mget(memc
, keys
, key_length
, 3));
1569 memcached_return_t rc
;
1570 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1575 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1576 test_false(results
);
1577 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1579 for (uint32_t x
= 0; x
< 3; x
++)
1581 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1582 keys
[x
], key_length
[x
],
1583 (time_t)50, (uint32_t)9);
1584 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1587 test_compare(MEMCACHED_SUCCESS
,
1588 memcached_mget(memc
, keys
, key_length
, 3));
1590 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1593 test_true(&results_obj
== results
);
1594 test_compare(MEMCACHED_SUCCESS
, rc
);
1595 test_memcmp(memcached_result_key_value(results
),
1596 memcached_result_value(results
),
1597 memcached_result_length(results
));
1598 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1601 memcached_result_free(&results_obj
);
1603 return TEST_SUCCESS
;
1606 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1608 const char *keys
[]= {"fudge", "son", "food"};
1609 size_t key_length
[]= {5, 3, 4};
1611 memcached_result_st
*results
;
1613 /* We need to empty the server before continueing test */
1614 test_compare(MEMCACHED_SUCCESS
,
1615 memcached_flush(memc
, 0));
1617 test_compare(MEMCACHED_SUCCESS
,
1618 memcached_mget(memc
, keys
, key_length
, 3));
1620 memcached_return_t rc
;
1621 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1625 test_false(results
);
1626 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1628 for (uint32_t x
= 0; x
< 3; x
++)
1630 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1631 keys
[x
], key_length
[x
],
1632 (time_t)50, (uint32_t)9);
1633 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1636 test_compare(MEMCACHED_SUCCESS
,
1637 memcached_mget(memc
, keys
, key_length
, 3));
1640 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1643 test_compare(MEMCACHED_SUCCESS
, rc
);
1644 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1645 test_memcmp(memcached_result_key_value(results
),
1646 memcached_result_value(results
),
1647 memcached_result_length(results
));
1648 memcached_result_free(results
);
1652 return TEST_SUCCESS
;
1655 /* Count the results */
1656 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1658 size_t *counter
= (size_t *)context
;
1660 *counter
= *counter
+ 1;
1662 return MEMCACHED_SUCCESS
;
1665 static test_return_t
mget_result_function(memcached_st
*memc
)
1667 const char *keys
[]= {"fudge", "son", "food"};
1668 size_t key_length
[]= {5, 3, 4};
1670 memcached_execute_fn callbacks
[1];
1672 /* We need to empty the server before continueing test */
1673 test_compare(MEMCACHED_SUCCESS
,
1674 memcached_flush(memc
, 0));
1675 for (uint32_t x
= 0; x
< 3; x
++)
1677 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1678 keys
[x
], key_length
[x
],
1679 (time_t)50, (uint32_t)9);
1680 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1683 test_compare(MEMCACHED_SUCCESS
,
1684 memcached_mget(memc
, keys
, key_length
, 3));
1686 callbacks
[0]= &callback_counter
;
1689 test_compare(MEMCACHED_SUCCESS
,
1690 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1692 test_compare(size_t(3), counter
);
1694 return TEST_SUCCESS
;
1697 static test_return_t
mget_test(memcached_st
*memc
)
1699 const char *keys
[]= {"fudge", "son", "food"};
1700 size_t key_length
[]= {5, 3, 4};
1702 char return_key
[MEMCACHED_MAX_KEY
];
1703 size_t return_key_length
;
1705 size_t return_value_length
;
1707 /* We need to empty the server before continueing test */
1708 test_compare(MEMCACHED_SUCCESS
,
1709 memcached_flush(memc
, 0));
1711 test_compare(MEMCACHED_SUCCESS
,
1712 memcached_mget(memc
, keys
, key_length
, 3));
1715 memcached_return_t rc
;
1716 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1717 &return_value_length
, &flags
, &rc
)))
1719 test_true(return_value
);
1721 test_false(return_value
);
1722 test_zero(return_value_length
);
1723 test_compare(MEMCACHED_NOTFOUND
, rc
);
1725 for (uint32_t x
= 0; x
< 3; x
++)
1727 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1728 keys
[x
], key_length
[x
],
1729 (time_t)50, (uint32_t)9);
1730 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1732 test_compare(MEMCACHED_SUCCESS
,
1733 memcached_mget(memc
, keys
, key_length
, 3));
1736 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1737 &return_value_length
, &flags
, &rc
)))
1739 test_true(return_value
);
1740 test_compare(MEMCACHED_SUCCESS
, rc
);
1741 if (not memc
->_namespace
)
1743 test_compare(return_key_length
, return_value_length
);
1744 test_memcmp(return_value
, return_key
, return_value_length
);
1750 return TEST_SUCCESS
;
1753 static test_return_t
mget_execute(memcached_st
*memc
)
1757 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1761 * I only want to hit _one_ server so I know the number of requests I'm
1762 * sending in the pipeline.
1764 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1765 memc
->number_of_hosts
= 1;
1767 size_t max_keys
= 20480;
1770 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1771 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1773 /* First add all of the items.. */
1774 char blob
[1024] = {0};
1775 memcached_return_t rc
;
1777 for (size_t x
= 0; x
< max_keys
; ++x
)
1781 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1783 test_true(keys
[x
] != NULL
);
1784 uint64_t query_id
= memcached_query_id(memc
);
1785 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1786 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1787 test_compare(query_id
+1, memcached_query_id(memc
));
1790 /* Try to get all of them with a large multiget */
1792 memcached_execute_fn callbacks
[]= { &callback_counter
};
1793 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1794 max_keys
, callbacks
, &counter
, 1);
1796 if (memcached_success(rc
))
1799 uint64_t query_id
= memcached_query_id(memc
);
1800 test_compare(MEMCACHED_SUCCESS
,
1801 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1802 test_compare(query_id
, memcached_query_id(memc
));
1804 /* Verify that we got all of the items */
1805 test_true(counter
== max_keys
);
1807 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1809 test_true(counter
== 0);
1813 test_fail("note: this test functions differently when in binary mode");
1816 /* Release all allocated resources */
1817 for (size_t x
= 0; x
< max_keys
; ++x
)
1824 memc
->number_of_hosts
= number_of_hosts
;
1825 return TEST_SUCCESS
;
1828 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1830 static test_return_t
key_setup(memcached_st
*memc
)
1832 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1834 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1836 return TEST_SUCCESS
;
1839 static test_return_t
key_teardown(memcached_st
*memc
)
1842 pairs_free(global_pairs
);
1844 return TEST_SUCCESS
;
1847 static test_return_t
block_add_regression(memcached_st
*memc
)
1849 /* First add all of the items.. */
1850 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1852 memcached_return_t rc
;
1853 char blob
[1024] = {0};
1855 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1856 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1859 return TEST_SUCCESS
;
1862 static test_return_t
binary_add_regression(memcached_st
*memc
)
1864 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1865 test_return_t rc
= block_add_regression(memc
);
1866 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1870 static test_return_t
get_stats_keys(memcached_st
*memc
)
1874 memcached_stat_st memc_stat
;
1875 memcached_return_t rc
;
1877 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1878 test_compare(MEMCACHED_SUCCESS
, rc
);
1879 for (ptr
= stat_list
; *ptr
; ptr
++)
1884 return TEST_SUCCESS
;
1887 static test_return_t
version_string_test(memcached_st
*memc
)
1889 const char *version_string
;
1892 version_string
= memcached_lib_version();
1894 test_strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
);
1896 return TEST_SUCCESS
;
1899 static test_return_t
get_stats(memcached_st
*memc
)
1901 memcached_return_t rc
;
1903 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1904 test_compare(MEMCACHED_SUCCESS
, rc
);
1905 test_true(memc_stat
);
1907 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1909 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1910 test_compare(MEMCACHED_SUCCESS
, rc
);
1911 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1916 memcached_stat_free(NULL
, memc_stat
);
1918 return TEST_SUCCESS
;
1921 static test_return_t
add_host_test(memcached_st
*memc
)
1924 memcached_server_st
*servers
;
1925 memcached_return_t rc
;
1926 char servername
[]= "0.example.com";
1928 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1930 test_true(1 == memcached_server_list_count(servers
));
1932 for (x
= 2; x
< 20; x
++)
1934 char buffer
[SMALL_STRING_LEN
];
1936 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1937 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1939 test_compare(MEMCACHED_SUCCESS
, rc
);
1940 test_true(x
== memcached_server_list_count(servers
));
1943 rc
= memcached_server_push(memc
, servers
);
1944 test_compare(MEMCACHED_SUCCESS
, rc
);
1945 rc
= memcached_server_push(memc
, servers
);
1946 test_compare(MEMCACHED_SUCCESS
, rc
);
1948 memcached_server_list_free(servers
);
1950 return TEST_SUCCESS
;
1953 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1955 memcached_return_t rc
;
1956 const char *key
= "not_found";
1957 size_t key_len
= strlen(key
);
1959 test_compare(MEMCACHED_SUCCESS
,
1960 memcached_mget(memc
, &key
, &key_len
, 1));
1962 memcached_result_st
*result
= NULL
;
1963 result
= memcached_fetch_result(memc
, result
, &rc
);
1965 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1967 memcached_result_free(result
);
1969 return TEST_SUCCESS
;
1972 static memcached_return_t
clone_test_callback(memcached_st
*parent
, memcached_st
*memc_clone
)
1974 (void)parent
;(void)memc_clone
;
1975 return MEMCACHED_SUCCESS
;
1978 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
)
1981 return MEMCACHED_SUCCESS
;
1984 static test_return_t
callback_test(memcached_st
*memc
)
1986 /* Test User Data */
1990 memcached_return_t rc
;
1992 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1993 test_compare(MEMCACHED_SUCCESS
, rc
);
1994 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1995 test_true(*test_ptr
== x
);
1998 /* Test Clone Callback */
2000 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2001 void *clone_cb_ptr
= *(void **)&clone_cb
;
2002 void *temp_function
= NULL
;
2003 memcached_return_t rc
;
2005 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2007 test_compare(MEMCACHED_SUCCESS
, rc
);
2008 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2009 test_true(temp_function
== clone_cb_ptr
);
2012 /* Test Cleanup Callback */
2014 memcached_cleanup_fn cleanup_cb
=
2015 (memcached_cleanup_fn
)cleanup_test_callback
;
2016 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2017 void *temp_function
= NULL
;
2018 memcached_return_t rc
;
2020 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2022 test_compare(MEMCACHED_SUCCESS
, rc
);
2023 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2024 test_true(temp_function
== cleanup_cb_ptr
);
2027 return TEST_SUCCESS
;
2030 /* We don't test the behavior itself, we test the switches */
2031 static test_return_t
behavior_test(memcached_st
*memc
)
2036 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2037 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2038 test_true(value
== 1);
2040 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2041 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2042 test_true(value
== 1);
2044 set
= MEMCACHED_HASH_MD5
;
2045 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2046 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2047 test_true(value
== MEMCACHED_HASH_MD5
);
2051 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2052 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2053 test_true(value
== 0);
2055 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2056 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2057 test_true(value
== 0);
2059 set
= MEMCACHED_HASH_DEFAULT
;
2060 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2061 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2062 test_true(value
== MEMCACHED_HASH_DEFAULT
);
2064 set
= MEMCACHED_HASH_CRC
;
2065 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2066 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2067 test_true(value
== MEMCACHED_HASH_CRC
);
2069 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2070 test_true(value
> 0);
2072 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2073 test_true(value
> 0);
2075 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2076 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
2077 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2079 return TEST_SUCCESS
;
2082 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2084 memcached_return_t rc
;
2087 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
2088 test_true(rc
== MEMCACHED_DEPRECATED
);
2090 // Platform dependent
2092 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2096 return TEST_SUCCESS
;
2100 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2102 memcached_return_t rc
;
2106 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, set
);
2107 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2109 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2111 if (rc
== MEMCACHED_SUCCESS
)
2113 test_true((bool)value
== set
);
2117 test_false((bool)value
== set
);
2120 return TEST_SUCCESS
;
2124 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2126 memcached_return_t rc
;
2130 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, set
);
2131 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2133 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2135 if (rc
== MEMCACHED_SUCCESS
)
2137 test_true((bool)value
== set
);
2141 test_false((bool)value
== set
);
2144 return TEST_SUCCESS
;
2147 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, const memcached_return_t expect
)
2149 memcached_return_t rc
;
2150 char return_key
[MEMCACHED_MAX_KEY
];
2151 size_t return_key_length
;
2153 size_t return_value_length
;
2157 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2158 &return_value_length
, &flags
, &rc
)))
2160 test_true(return_value
);
2161 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2166 if (memcached_success(expect
) and memcached_success(rc
))
2168 return TEST_SUCCESS
;
2170 else if (expect
== rc
)
2172 return TEST_SUCCESS
;
2174 fprintf(stderr
, "\n%s:%u %s(#%u)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), keys_returned
);
2176 return TEST_FAILURE
;
2179 /* Test case provided by Cal Haldenbrand */
2180 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2181 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2182 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2184 /* We just keep looking at the same values over and over */
2187 unsigned int setter
= 1;
2188 test_compare(MEMCACHED_SUCCESS
,
2189 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2190 test_compare(MEMCACHED_SUCCESS
,
2191 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2195 unsigned long long total
= 0;
2196 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2198 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2199 char randomstuff
[6 * 1024];
2200 memset(randomstuff
, 0, 6 * 1024);
2201 test_true(size
< 6 * 1024); /* Being safe here */
2203 for (uint32_t j
= 0 ; j
< size
;j
++)
2205 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2210 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2211 test_compare(MEMCACHED_SUCCESS
,
2212 memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
));
2214 test_true(total
> HALDENBRAND_KEY_COUNT
);
2216 return TEST_SUCCESS
;
2219 /* Test case provided by Cal Haldenbrand */
2220 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2222 unsigned int setter
= 1;
2224 test_compare(MEMCACHED_SUCCESS
,
2225 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2227 test_compare(MEMCACHED_SUCCESS
,
2228 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2231 setter
= 20 * 1024576;
2232 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2233 setter
= 20 * 1024576;
2234 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2235 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2236 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2238 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2241 size_t total_value_length
= 0;
2242 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2247 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2248 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2250 memcached_return_t rc
;
2251 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2252 if (memcached_failed(rc
))
2254 if (rc
== MEMCACHED_NOTFOUND
)
2265 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2267 total_value_length
+= val_len
;
2272 return TEST_SUCCESS
;
2275 /* Do a large mget() over all the keys we think exist */
2276 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2278 test_compare(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
2279 test_compare(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
2281 setter
= 20 * 1024576;
2282 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2283 setter
= 20 * 1024576;
2284 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2285 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2286 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2289 size_t key_lengths
[HALDENBRAND_KEY_COUNT
];
2290 char **keys
= static_cast<char **>(calloc(HALDENBRAND_KEY_COUNT
, sizeof(char *)));
2292 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2294 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2295 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2296 test_true(key_length
);
2297 keys
[x
]= strdup(key
);
2299 key_lengths
[x
]= key_length
;
2300 test_compare(size_t(key_length
), strlen(keys
[x
]));
2303 test_compare(MEMCACHED_SUCCESS
,
2304 memcached_mget(memc
, (const char **)keys
, key_lengths
, HALDENBRAND_KEY_COUNT
));
2306 unsigned int keys_returned
;
2307 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
2308 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2310 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2316 return TEST_SUCCESS
;
2319 /* Make sure we behave properly if server list has no values */
2320 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2322 const char *keys
[]= {"fudge", "son", "food"};
2323 size_t key_length
[]= {5, 3, 4};
2325 /* Here we free everything before running a bunch of mget tests */
2326 memcached_servers_reset(memc
);
2329 /* We need to empty the server before continueing test */
2330 test_compare(MEMCACHED_NO_SERVERS
,
2331 memcached_flush(memc
, 0));
2333 test_compare(MEMCACHED_NO_SERVERS
,
2334 memcached_mget(memc
, keys
, key_length
, 3));
2336 unsigned int keys_returned
;
2337 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2338 test_zero(keys_returned
);
2340 for (uint32_t x
= 0; x
< 3; x
++)
2342 test_compare(MEMCACHED_NO_SERVERS
,
2343 memcached_set(memc
, keys
[x
], key_length
[x
],
2344 keys
[x
], key_length
[x
],
2345 (time_t)50, (uint32_t)9));
2348 test_compare(MEMCACHED_NO_SERVERS
,
2349 memcached_mget(memc
, keys
, key_length
, 3));
2353 char return_key
[MEMCACHED_MAX_KEY
];
2354 memcached_return_t rc
;
2355 size_t return_key_length
;
2356 size_t return_value_length
;
2359 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2360 &return_value_length
, &flags
, &rc
)))
2362 test_true(return_value
);
2363 test_compare(MEMCACHED_SUCCESS
, rc
);
2364 test_true(return_key_length
== return_value_length
);
2365 test_memcmp(return_value
, return_key
, return_value_length
);
2371 return TEST_SUCCESS
;
2374 #define VALUE_SIZE_BUG5 1048064
2375 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2377 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2378 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2380 size_t value_length
;
2382 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2384 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2386 insert_data
[x
]= (signed char)rand();
2389 test_compare(MEMCACHED_SUCCESS
,
2390 memcached_flush(memc
, 0));
2392 memcached_return_t rc
;
2393 value
= memcached_get(memc
, keys
[0], key_length
[0],
2394 &value_length
, &flags
, &rc
);
2396 test_compare(MEMCACHED_SUCCESS
,
2397 memcached_mget(memc
, keys
, key_length
, 4));
2400 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2403 for (uint32_t x
= 0; x
< 4; x
++)
2405 test_compare(MEMCACHED_SUCCESS
,
2406 memcached_set(memc
, keys
[x
], key_length
[x
],
2407 insert_data
, VALUE_SIZE_BUG5
,
2408 (time_t)0, (uint32_t)0));
2411 for (uint32_t x
= 0; x
< 10; x
++)
2413 value
= memcached_get(memc
, keys
[0], key_length
[0],
2414 &value_length
, &flags
, &rc
);
2415 test_compare(rc
, MEMCACHED_SUCCESS
);
2419 test_compare(MEMCACHED_SUCCESS
,
2420 memcached_mget(memc
, keys
, key_length
, 4));
2422 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2423 test_compare(4U, count
);
2425 delete [] insert_data
;
2427 return TEST_SUCCESS
;
2430 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2432 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2433 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2434 char return_key
[MEMCACHED_MAX_KEY
];
2435 size_t return_key_length
;
2437 size_t value_length
;
2439 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2441 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2443 insert_data
[x
]= (signed char)rand();
2446 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2448 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2450 // We will now confirm that memcached_mget() returns success, but we will
2451 // then check to make sure that no actual keys are returned.
2452 test_compare(MEMCACHED_SUCCESS
,
2453 memcached_mget(memc
, keys
, key_length
, 4));
2455 memcached_return_t rc
;
2457 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2458 &value_length
, &flags
, &rc
)))
2463 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2465 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2467 test_compare(MEMCACHED_SUCCESS
,
2468 memcached_set(memc
, keys
[x
], key_length
[x
],
2469 insert_data
, VALUE_SIZE_BUG5
,
2470 (time_t)0, (uint32_t)0));
2472 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2474 for (uint32_t x
= 0; x
< 2; x
++)
2476 value
= memcached_get(memc
, keys
[0], key_length
[0],
2477 &value_length
, &flags
, &rc
);
2481 test_compare(MEMCACHED_SUCCESS
,
2482 memcached_mget(memc
, keys
, key_length
, 4));
2483 /* We test for purge of partial complete fetches */
2484 for (count
= 3; count
; count
--)
2486 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2487 &value_length
, &flags
, &rc
);
2488 test_compare(MEMCACHED_SUCCESS
, rc
);
2489 test_memcmp(value
, insert_data
, value_length
);
2490 test_true(value_length
);
2494 delete [] insert_data
;
2496 return TEST_SUCCESS
;
2499 static test_return_t
user_supplied_bug8(memcached_st
*)
2501 memcached_return_t rc
;
2503 memcached_st
*memc_clone
;
2505 memcached_server_st
*servers
;
2506 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";
2508 servers
= memcached_servers_parse(server_list
);
2511 mine
= memcached_create(NULL
);
2512 rc
= memcached_server_push(mine
, servers
);
2513 test_compare(MEMCACHED_SUCCESS
, rc
);
2514 memcached_server_list_free(servers
);
2517 memc_clone
= memcached_clone(NULL
, mine
);
2519 memcached_quit(mine
);
2520 memcached_quit(memc_clone
);
2523 memcached_free(mine
);
2524 memcached_free(memc_clone
);
2526 return TEST_SUCCESS
;
2529 /* Test flag store/retrieve */
2530 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2532 const char *keys
= "036790384900";
2533 size_t key_length
= strlen(keys
);
2534 char return_key
[MEMCACHED_MAX_KEY
];
2535 size_t return_key_length
;
2537 size_t value_length
;
2539 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2541 for (unsigned int x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2542 insert_data
[x
]= (signed char)rand();
2544 memcached_flush(memc
, 0);
2547 memcached_return_t rc
= memcached_set(memc
, keys
, key_length
,
2548 insert_data
, VALUE_SIZE_BUG5
,
2550 test_compare(MEMCACHED_SUCCESS
, rc
);
2553 value
= memcached_get(memc
, keys
, key_length
,
2554 &value_length
, &flags
, &rc
);
2555 test_true(flags
== 245);
2559 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2562 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2563 &value_length
, &flags
, &rc
);
2564 test_compare(uint32_t(245), flags
);
2567 delete [] insert_data
;
2570 return TEST_SUCCESS
;
2573 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2575 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2576 size_t key_length
[3];
2580 char return_key
[MEMCACHED_MAX_KEY
];
2581 size_t return_key_length
;
2583 size_t return_value_length
;
2586 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2587 key_length
[1]= strlen("fudge&*@#");
2588 key_length
[2]= strlen("for^#@&$not");
2591 for (unsigned int x
= 0; x
< 3; x
++)
2593 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2594 keys
[x
], key_length
[x
],
2595 (time_t)50, (uint32_t)9);
2596 test_compare(MEMCACHED_SUCCESS
, rc
);
2599 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2600 test_compare(MEMCACHED_SUCCESS
, rc
);
2602 /* We need to empty the server before continueing test */
2603 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2604 &return_value_length
, &flags
, &rc
)) != NULL
)
2606 test_true(return_value
);
2610 test_compare(3U, count
);
2612 return TEST_SUCCESS
;
2615 /* We are testing with aggressive timeout to get failures */
2616 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2618 size_t value_length
= 512;
2619 unsigned int set
= 1;
2620 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2622 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2623 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2624 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2626 char *value
= (char*)malloc(value_length
* sizeof(char));
2628 for (unsigned int x
= 0; x
< value_length
; x
++)
2630 value
[x
]= (char) (x
% 127);
2633 for (unsigned int x
= 1; x
<= 100000; ++x
)
2635 memcached_return_t rc
= memcached_set(mclone
,
2636 test_literal_param("foo"),
2637 value
, value_length
, 0, 0);
2639 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2640 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2641 memcached_strerror(NULL
, rc
));
2643 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2650 memcached_free(mclone
);
2652 return TEST_SUCCESS
;
2656 We are looking failures in the async protocol
2658 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2660 const char *key
= "foo";
2661 size_t value_length
= 512;
2663 unsigned int set
= 1;
2664 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2666 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2667 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2668 int32_t timeout
= -1;
2669 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, (size_t)timeout
);
2671 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2673 test_true(timeout
== -1);
2675 char *value
= (char*)malloc(value_length
* sizeof(char));
2677 for (unsigned int x
= 0; x
< value_length
; x
++)
2679 value
[x
]= (char) (x
% 127);
2682 for (unsigned int x
= 1; x
<= 100000; ++x
)
2684 memcached_return_t rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2689 memcached_free(mclone
);
2691 return TEST_SUCCESS
;
2695 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2697 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2699 memcached_return_t rc
;
2701 size_t value_length
;
2703 uint64_t number_value
;
2705 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2706 &value_length
, &flags
, &rc
);
2707 test_true(value
== NULL
);
2708 test_compare(MEMCACHED_NOTFOUND
, rc
);
2710 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2713 test_true(value
== NULL
);
2714 /* The binary protocol will set the key if it doesn't exist */
2715 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2717 test_compare(MEMCACHED_SUCCESS
, rc
);
2721 test_compare(MEMCACHED_NOTFOUND
, rc
);
2724 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2726 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2727 &value_length
, &flags
, &rc
);
2729 test_compare(MEMCACHED_SUCCESS
, rc
);
2732 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2734 test_true(number_value
== 2);
2735 test_compare(MEMCACHED_SUCCESS
, rc
);
2737 return TEST_SUCCESS
;
2741 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2742 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2744 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2746 char key
[] = "key34567890";
2747 memcached_return_t rc
;
2748 size_t overflowSize
;
2750 char commandFirst
[]= "set key34567890 0 0 ";
2751 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2752 size_t commandLength
;
2755 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2757 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2759 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2761 char *overflow
= new (std::nothrow
) char[testSize
];
2762 test_true(overflow
);
2764 memset(overflow
, 'x', testSize
);
2765 rc
= memcached_set(memc
, key
, strlen(key
),
2766 overflow
, testSize
, 0, 0);
2767 test_compare(MEMCACHED_SUCCESS
, rc
);
2771 return TEST_SUCCESS
;
2776 Test values of many different sizes
2777 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2778 set key34567890 0 0 8169 \r\n
2779 is sent followed by buffer of size 8169, followed by 8169
2781 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2783 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2785 std::vector
<char> value
;
2786 for (size_t x
= 0; x
< 18000; x
++)
2788 value
.push_back((char) (x
% 127));
2791 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2793 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2794 &value
[0], current_length
,
2795 (time_t)0, (uint32_t)0);
2796 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2798 size_t string_length
;
2800 char *string
= memcached_get(memc
, test_literal_param("foo"),
2801 &string_length
, &flags
, &rc
);
2803 test_compare(MEMCACHED_SUCCESS
, rc
);
2804 test_compare(string_length
, current_length
);
2805 test_memcmp(string
, &value
[0], string_length
);
2810 return TEST_SUCCESS
;
2814 Look for zero length value problems
2816 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2818 for (uint32_t x
= 0; x
< 2; x
++)
2820 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2822 (time_t)0, (uint32_t)0);
2824 test_compare(MEMCACHED_SUCCESS
, rc
);
2828 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2829 &length
, &flags
, &rc
);
2831 test_compare(MEMCACHED_SUCCESS
, rc
);
2836 value
= memcached_get(memc
, test_literal_param("mykey"),
2837 &length
, &flags
, &rc
);
2839 test_compare(MEMCACHED_SUCCESS
, rc
);
2840 test_true(value
== NULL
);
2845 return TEST_SUCCESS
;
2848 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2849 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2851 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2853 (time_t)0, UINT32_MAX
);
2855 test_compare(MEMCACHED_SUCCESS
, rc
);
2859 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2860 &length
, &flags
, &rc
);
2862 test_compare(MEMCACHED_SUCCESS
, rc
);
2863 test_true(value
== NULL
);
2865 test_compare(flags
, UINT32_MAX
);
2867 return TEST_SUCCESS
;
2870 #if !defined(__sun) && !defined(__OpenBSD__)
2871 /* Check the validity of chinese key*/
2872 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2874 const char *key
= "豆瓣";
2875 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2876 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2877 value
, strlen(value
),
2880 test_compare(MEMCACHED_SUCCESS
, rc
);
2884 char *value2
= memcached_get(memc
, key
, strlen(key
),
2885 &length
, &flags
, &rc
);
2887 test_true(length
==strlen(value
));
2888 test_compare(MEMCACHED_SUCCESS
, rc
);
2889 test_memcmp(value
, value2
, length
);
2892 return TEST_SUCCESS
;
2900 static test_return_t
user_supplied_bug19(memcached_st
*)
2902 memcached_return_t res
;
2904 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2906 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2909 memcached_free(memc
);
2911 return TEST_SUCCESS
;
2914 /* CAS test from Andei */
2915 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2917 const char *key
= "abc";
2918 size_t key_len
= strlen("abc");
2920 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2922 test_compare(MEMCACHED_SUCCESS
,
2924 test_literal_param("abc"),
2925 test_literal_param("foobar"),
2926 (time_t)0, (uint32_t)0));
2928 test_compare(MEMCACHED_SUCCESS
,
2929 memcached_mget(memc
, &key
, &key_len
, 1));
2931 memcached_result_st result_obj
;
2932 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2935 memcached_result_create(memc
, &result_obj
);
2936 memcached_return_t status
;
2937 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2940 test_compare(MEMCACHED_SUCCESS
, status
);
2942 memcached_result_free(result
);
2944 return TEST_SUCCESS
;
2947 /* Large mget() of missing keys with binary proto
2949 * If many binary quiet commands (such as getq's in an mget) fill the output
2950 * buffer and the server chooses not to respond, memcached_flush hangs. See
2951 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2954 /* sighandler_t function that always asserts false */
2955 static void fail(int)
2961 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2966 return TEST_SKIPPED
;
2968 void (*oldalarm
)(int);
2970 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2971 test_true(memc_clone
);
2973 /* only binproto uses getq for mget */
2974 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2976 /* empty the cache to ensure misses (hence non-responses) */
2977 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2979 size_t* key_lengths
= new (std::nothrow
) size_t[key_count
];
2980 test_true(key_lengths
);
2981 char **keys
= static_cast<char **>(calloc(key_count
, sizeof(char *)));
2983 for (unsigned int x
= 0; x
< key_count
; x
++)
2987 snprintf(buffer
, 30, "%u", x
);
2988 keys
[x
]= strdup(buffer
);
2990 key_lengths
[x
]= strlen(keys
[x
]);
2993 oldalarm
= signal(SIGALRM
, fail
);
2996 test_compare_got(MEMCACHED_SUCCESS
,
2997 memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
), memcached_last_error_message(memc_clone
));
3000 signal(SIGALRM
, oldalarm
);
3002 memcached_return_t rc
;
3004 char return_key
[MEMCACHED_MAX_KEY
];
3005 size_t return_key_length
;
3007 size_t return_value_length
;
3008 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
3009 &return_value_length
, &flags
, &rc
)))
3011 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
3013 test_compare(MEMCACHED_NOTFOUND
, rc
);
3014 test_zero(return_value_length
);
3015 test_zero(return_key_length
);
3016 test_false(return_key
[0]);
3017 test_false(return_value
);
3019 for (unsigned int x
= 0; x
< key_count
; x
++)
3024 delete [] key_lengths
;
3026 memcached_free(memc_clone
);
3028 return TEST_SUCCESS
;
3032 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3034 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3036 /* should work as of r580 */
3037 test_compare(TEST_SUCCESS
,
3038 _user_supplied_bug21(memc
, 10));
3040 /* should fail as of r580 */
3041 test_compare(TEST_SUCCESS
,
3042 _user_supplied_bug21(memc
, 1000));
3044 return TEST_SUCCESS
;
3047 static test_return_t
output_ketama_weighted_keys(memcached_st
*)
3049 memcached_st
*memc
= memcached_create(NULL
);
3053 test_compare(MEMCACHED_SUCCESS
,
3054 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
3056 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3057 test_compare(value
, uint64_t(1));
3059 test_compare(MEMCACHED_SUCCESS
,
3060 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3062 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3063 test_true(value
== MEMCACHED_HASH_MD5
);
3066 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3068 memcached_server_st
*server_pool
;
3069 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");
3070 memcached_server_push(memc
, server_pool
);
3072 // @todo this needs to be refactored to actually test something.
3075 if ((fp
= fopen("ketama_keys.txt", "w")))
3079 printf("cannot write to file ketama_keys.txt");
3080 return TEST_FAILURE
;
3083 for (int x
= 0; x
< 10000; x
++)
3086 snprintf(key
, sizeof(key
), "%d", x
);
3088 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3089 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3090 in_port_t port
= memc
->hosts
[server_idx
].port
;
3091 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3092 memcached_server_instance_st instance
=
3093 memcached_server_instance_by_position(memc
, host_index
);
3097 memcached_server_list_free(server_pool
);
3098 memcached_free(memc
);
3100 return TEST_SUCCESS
;
3104 static test_return_t
result_static(memcached_st
*memc
)
3106 memcached_result_st result
;
3107 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3108 test_false(result
.options
.is_allocated
);
3109 test_true(memcached_is_initialized(&result
));
3110 test_true(result_ptr
);
3111 test_true(result_ptr
== &result
);
3113 memcached_result_free(&result
);
3115 test_false(result
.options
.is_allocated
);
3116 test_false(memcached_is_initialized(&result
));
3118 return TEST_SUCCESS
;
3121 static test_return_t
result_alloc(memcached_st
*memc
)
3123 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3124 test_true(result_ptr
);
3125 test_true(result_ptr
->options
.is_allocated
);
3126 test_true(memcached_is_initialized(result_ptr
));
3127 memcached_result_free(result_ptr
);
3129 return TEST_SUCCESS
;
3132 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3135 pairs_free(global_pairs
);
3137 return TEST_SUCCESS
;
3140 static test_return_t
generate_pairs(memcached_st
*)
3142 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3143 global_count
= GLOBAL_COUNT
;
3145 for (size_t x
= 0; x
< global_count
; x
++)
3147 global_keys
[x
]= global_pairs
[x
].key
;
3148 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3151 return TEST_SUCCESS
;
3154 static test_return_t
generate_large_pairs(memcached_st
*)
3156 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3157 global_count
= GLOBAL2_COUNT
;
3159 for (size_t x
= 0; x
< global_count
; x
++)
3161 global_keys
[x
]= global_pairs
[x
].key
;
3162 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3165 return TEST_SUCCESS
;
3168 static test_return_t
generate_data(memcached_st
*memc
)
3170 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3172 test_compare(check_execute
, global_count
);
3174 return TEST_SUCCESS
;
3177 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3179 uint32_t host_index
= 0;
3180 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3182 test_true(check_execute
== global_count
);
3184 // @todo hosts used size stats
3185 memcached_return_t rc
;
3186 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3189 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3191 /* This test was changes so that "make test" would work properlly */
3194 memcached_server_instance_st instance
=
3195 memcached_server_instance_by_position(memc
, host_index
);
3197 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3199 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3202 memcached_stat_free(NULL
, stat_p
);
3204 return TEST_SUCCESS
;
3206 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3208 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3209 generate_data(memc
);
3211 return TEST_SUCCESS
;
3214 static test_return_t
get_read_count(memcached_st
*memc
)
3216 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3217 test_true(memc_clone
);
3219 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3223 size_t return_value_length
;
3227 for (size_t x
= count
= 0; x
< global_count
; x
++)
3229 memcached_return_t rc
;
3230 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3231 &return_value_length
, &flags
, &rc
);
3232 if (rc
== MEMCACHED_SUCCESS
)
3243 memcached_free(memc_clone
);
3245 return TEST_SUCCESS
;
3248 static test_return_t
get_read(memcached_st
*memc
)
3250 for (size_t x
= 0; x
< global_count
; x
++)
3252 size_t return_value_length
;
3254 memcached_return_t rc
;
3255 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3256 &return_value_length
, &flags
, &rc
);
3258 test_true(return_value);
3259 test_compare(MEMCACHED_SUCCESS, rc);
3261 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3267 return TEST_SUCCESS
;
3270 static test_return_t
mget_read(memcached_st
*memc
)
3273 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3275 test_compare(MEMCACHED_SUCCESS
,
3276 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3278 // Go fetch the keys and test to see if all of them were returned
3280 unsigned int keys_returned
;
3281 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3282 test_true(keys_returned
> 0);
3283 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3286 return TEST_SUCCESS
;
3289 static test_return_t
mget_read_result(memcached_st
*memc
)
3292 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3294 test_compare(MEMCACHED_SUCCESS
,
3295 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3297 /* Turn this into a help function */
3299 memcached_result_st results_obj
;
3300 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3303 memcached_return_t rc
;
3304 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3306 if (rc
== MEMCACHED_IN_PROGRESS
)
3312 test_compare(MEMCACHED_SUCCESS
, rc
);
3314 test_compare(MEMCACHED_END
, rc
);
3316 memcached_result_free(&results_obj
);
3319 return TEST_SUCCESS
;
3322 static test_return_t
mget_read_internal_result(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_result_st
*results
= NULL
;
3331 memcached_return_t rc
;
3332 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3335 test_compare(MEMCACHED_SUCCESS
, rc
);
3337 test_compare(MEMCACHED_END
, rc
);
3339 memcached_result_free(results
);
3342 return TEST_SUCCESS
;
3345 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3348 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3350 test_compare(MEMCACHED_SUCCESS
,
3351 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3353 // We will scan for just one key
3355 memcached_result_st results_obj
;
3356 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3358 memcached_return_t rc
;
3359 results
= memcached_fetch_result(memc
, results
, &rc
);
3361 test_compare(MEMCACHED_SUCCESS
, rc
);
3363 memcached_result_free(&results_obj
);
3366 // We already have a read happening, lets start up another one.
3367 test_compare(MEMCACHED_SUCCESS
,
3368 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3370 memcached_result_st results_obj
;
3371 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3373 test_false(memcached_is_allocated(results
));
3375 memcached_return_t rc
;
3376 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3379 test_compare(MEMCACHED_SUCCESS
, rc
);
3381 test_compare(MEMCACHED_END
, rc
);
3383 memcached_result_free(&results_obj
);
3386 return TEST_SUCCESS
;
3389 static test_return_t
mget_read_function(memcached_st
*memc
)
3391 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3393 test_compare(MEMCACHED_SUCCESS
,
3394 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3396 memcached_execute_fn callbacks
[]= { &callback_counter
};
3398 test_compare(MEMCACHED_SUCCESS
,
3399 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3401 return TEST_SUCCESS
;
3404 static test_return_t
delete_generate(memcached_st
*memc
)
3406 for (size_t x
= 0; x
< global_count
; x
++)
3408 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3411 return TEST_SUCCESS
;
3414 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3416 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3418 for (size_t x
= 0; x
< global_count
; x
++)
3420 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3423 return TEST_SUCCESS
;
3426 static test_return_t
add_host_test1(memcached_st
*memc
)
3428 memcached_return_t rc
;
3429 char servername
[]= "0.example.com";
3431 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3433 test_compare(1U, memcached_server_list_count(servers
));
3435 for (uint32_t x
= 2; x
< 20; x
++)
3437 char buffer
[SMALL_STRING_LEN
];
3439 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3440 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3442 test_compare(MEMCACHED_SUCCESS
, rc
);
3443 test_compare(x
, memcached_server_list_count(servers
));
3446 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3447 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3449 memcached_server_list_free(servers
);
3451 return TEST_SUCCESS
;
3454 static test_return_t
pre_nonblock(memcached_st
*memc
)
3456 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3458 return TEST_SUCCESS
;
3461 static test_return_t
pre_cork(memcached_st
*memc
)
3464 return TEST_SKIPPED
;
3467 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3468 return TEST_SUCCESS
;
3470 return TEST_SKIPPED
;
3473 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3476 return TEST_SKIPPED
;
3478 test_return_t test_rc
;
3479 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3482 return pre_nonblock(memc
);
3485 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3487 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3488 test_true(memc_clone
);
3490 // The memcached_version needs to be done on a clone, because the server
3491 // will not toggle protocol on an connection.
3492 memcached_version(memc_clone
);
3494 memcached_return_t rc
= MEMCACHED_FAILURE
;
3495 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3497 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3498 test_compare(MEMCACHED_SUCCESS
,
3499 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3500 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3504 memcached_free(memc_clone
);
3505 return TEST_SKIPPED
;
3508 memcached_free(memc_clone
);
3510 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3513 static test_return_t
pre_murmur(memcached_st
*memc
)
3515 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3516 return TEST_SUCCESS
;
3519 static test_return_t
pre_jenkins(memcached_st
*memc
)
3521 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3523 return TEST_SUCCESS
;
3527 static test_return_t
pre_md5(memcached_st
*memc
)
3529 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3531 return TEST_SUCCESS
;
3534 static test_return_t
pre_crc(memcached_st
*memc
)
3536 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3538 return TEST_SUCCESS
;
3541 static test_return_t
pre_hsieh(memcached_st
*memc
)
3543 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
));
3544 return TEST_SUCCESS
;
3547 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3549 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3551 return TEST_SUCCESS
;
3554 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3556 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
));
3558 return TEST_SUCCESS
;
3561 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3563 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3565 return TEST_SUCCESS
;
3568 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3570 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3572 return TEST_SUCCESS
;
3575 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3577 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3578 test_compare(MEMCACHED_SUCCESS
, rc
);
3580 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3581 test_compare(value
, uint64_t(1));
3583 return TEST_SUCCESS
;
3586 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3588 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3589 test_compare(MEMCACHED_SUCCESS
, rc
);
3591 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3592 test_compare(value
, uint64_t(1));
3594 test_compare(MEMCACHED_SUCCESS
,
3595 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3597 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3598 test_compare(MEMCACHED_HASH_MD5
, memcached_hash_t(value
));
3600 return TEST_SUCCESS
;
3603 static test_return_t
pre_replication(memcached_st
*memc
)
3605 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3608 * Make sure that we store the item on all servers
3609 * (master + replicas == number of servers)
3611 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3612 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3614 return TEST_SUCCESS
;
3618 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3620 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3622 return pre_nonblock(memc
);
3626 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3630 #ifdef HARD_MALLOC_TESTS
3631 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3639 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3643 #ifdef HARD_MALLOC_TESTS
3644 void *ret
= malloc(size
+ 8);
3647 ret
= (void*)((caddr_t
)ret
+ 8);
3650 void *ret
= malloc(size
);
3655 memset(ret
, 0xff, size
);
3662 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3664 #ifdef HARD_MALLOC_TESTS
3665 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3666 void *nmem
= realloc(real_ptr
, size
+ 8);
3671 ret
= (void*)((caddr_t
)nmem
+ 8);
3677 return realloc(mem
, size
);
3682 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3684 #ifdef HARD_MALLOC_TESTS
3685 void *mem
= my_malloc(ptr
, nelem
* size
);
3688 memset(mem
, 0, nelem
* size
);
3694 return calloc(nelem
, size
);
3698 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3700 memcached_return_t rc
;
3701 const char *key
= "mine";
3704 /* Make sure be default none exists */
3705 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3707 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3709 /* Test a clean set */
3710 test_compare(MEMCACHED_SUCCESS
,
3711 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3713 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3715 test_memcmp(value
, key
, 4);
3716 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3718 /* Test that we can turn it off */
3719 test_compare(MEMCACHED_SUCCESS
,
3720 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3722 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3724 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3726 /* Now setup for main test */
3727 test_compare(MEMCACHED_SUCCESS
,
3728 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3730 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3732 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3733 test_memcmp(value
, key
, 4);
3735 /* Set to Zero, and then Set to something too large */
3738 memset(long_key
, 0, 255);
3740 test_compare(MEMCACHED_SUCCESS
,
3741 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3743 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3745 test_compare(MEMCACHED_SUCCESS
, rc
);
3747 /* Test a long key for failure */
3748 /* TODO, extend test to determine based on setting, what result should be */
3749 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3750 test_compare(MEMCACHED_SUCCESS
,
3751 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3753 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3754 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3755 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3756 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3758 /* Test for a bad prefix, but with a short key */
3759 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3760 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3762 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3763 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3766 return TEST_SUCCESS
;
3769 static test_return_t
set_namespace(memcached_st
*memc
)
3771 memcached_return_t rc
;
3772 const char *key
= "mine";
3775 // Make sure we default to a null namespace
3776 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3778 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3780 /* Test a clean set */
3781 test_compare(MEMCACHED_SUCCESS
,
3782 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3784 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3786 test_memcmp(value
, key
, 4);
3787 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3789 return TEST_SUCCESS
;
3792 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3794 test_return_if(pre_binary(memc
));
3795 test_return_if(set_namespace(memc
));
3797 return TEST_SUCCESS
;
3800 #ifdef MEMCACHED_ENABLE_DEPRECATED
3801 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3803 void *test_ptr
= NULL
;
3806 memcached_malloc_fn malloc_cb
=
3807 (memcached_malloc_fn
)my_malloc
;
3808 cb_ptr
= *(void **)&malloc_cb
;
3809 memcached_return_t rc
;
3811 test_compare(MEMCACHED_SUCCESS
,
3812 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3813 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3814 test_compare(MEMCACHED_SUCCESS
, rc
);
3815 test_true(test_ptr
== cb_ptr
);
3819 memcached_realloc_fn realloc_cb
=
3820 (memcached_realloc_fn
)my_realloc
;
3821 cb_ptr
= *(void **)&realloc_cb
;
3822 memcached_return_t rc
;
3824 test_compare(MEMCACHED_SUCCESS
,
3825 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3826 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3827 test_compare(MEMCACHED_SUCCESS
, rc
);
3828 test_true(test_ptr
== cb_ptr
);
3832 memcached_free_fn free_cb
=
3833 (memcached_free_fn
)my_free
;
3834 cb_ptr
= *(void **)&free_cb
;
3835 memcached_return_t rc
;
3837 test_compare(MEMCACHED_SUCCESS
,
3838 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3839 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3840 test_compare(MEMCACHED_SUCCESS
, rc
);
3841 test_true(test_ptr
== cb_ptr
);
3844 return TEST_SUCCESS
;
3849 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3851 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3852 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3853 my_realloc
, my_calloc
, NULL
));
3855 test_compare(MEMCACHED_SUCCESS
,
3856 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3857 my_realloc
, my_calloc
, NULL
));
3859 memcached_malloc_fn mem_malloc
;
3860 memcached_free_fn mem_free
;
3861 memcached_realloc_fn mem_realloc
;
3862 memcached_calloc_fn mem_calloc
;
3863 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3864 &mem_realloc
, &mem_calloc
);
3866 test_true(mem_malloc
== my_malloc
);
3867 test_true(mem_realloc
== my_realloc
);
3868 test_true(mem_calloc
== my_calloc
);
3869 test_true(mem_free
== my_free
);
3871 return TEST_SUCCESS
;
3874 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3877 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3878 memcached_hash_t hash
;
3879 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3880 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3883 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3884 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3886 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3888 if (hash
!= MEMCACHED_HASH_CRC
)
3889 return TEST_SKIPPED
;
3891 return TEST_SUCCESS
;
3894 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3897 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3898 memcached_hash_t hash
;
3899 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3900 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3905 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3906 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3908 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3910 if (hash
!= MEMCACHED_HASH_HSIEH
)
3911 return TEST_SKIPPED
;
3914 return TEST_SUCCESS
;
3917 static test_return_t
enable_cas(memcached_st
*memc
)
3919 unsigned int set
= 1;
3921 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3923 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3925 return TEST_SUCCESS
;
3928 return TEST_SKIPPED
;
3931 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3933 memcached_version(memc
);
3935 memcached_server_instance_st instance
=
3936 memcached_server_instance_by_position(memc
, 0);
3938 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3939 or instance
->minor_version
> 2)
3941 return TEST_SUCCESS
;
3944 return TEST_SKIPPED
;
3947 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3951 memcached_servers_reset(memc
);
3952 const char *socket_file
= default_socket();
3954 test_skip(0, stat(socket_file
, &buf
));
3956 test_compare(MEMCACHED_SUCCESS
,
3957 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
3959 return TEST_SUCCESS
;
3962 static test_return_t
pre_nodelay(memcached_st
*memc
)
3964 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3965 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3967 return TEST_SUCCESS
;
3970 static test_return_t
pre_settimer(memcached_st
*memc
)
3972 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3973 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3975 return TEST_SUCCESS
;
3978 static test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3980 const uint64_t timeout
= 100; // Not using, just checking that it sets
3982 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3984 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3986 return TEST_SUCCESS
;
3989 static test_return_t
noreply_test(memcached_st
*memc
)
3991 test_compare(MEMCACHED_SUCCESS
,
3992 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
3993 test_compare(MEMCACHED_SUCCESS
,
3994 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1));
3995 test_compare(MEMCACHED_SUCCESS
,
3996 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
3997 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3998 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3999 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
4001 memcached_return_t ret
;
4002 for (int count
= 0; count
< 5; ++count
)
4004 for (size_t x
= 0; x
< 100; ++x
)
4007 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4008 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4010 size_t len
= (size_t)check_length
;
4015 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4018 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4021 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4024 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4027 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4033 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, ret
));
4037 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4038 ** API and is _ONLY_ done this way to verify that the library works the
4039 ** way it is supposed to do!!!!
4042 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4044 memcached_server_instance_st instance
=
4045 memcached_server_instance_by_position(memc
, x
);
4046 no_msg
+=(int)(instance
->cursor_active
);
4049 test_true(no_msg
== 0);
4050 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4053 ** Now validate that all items was set properly!
4055 for (size_t x
= 0; x
< 100; ++x
)
4059 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4061 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4063 size_t len
= (size_t)check_length
;
4066 char* value
=memcached_get(memc
, key
, strlen(key
),
4067 &length
, &flags
, &ret
);
4068 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
4071 case 0: /* FALLTHROUGH */
4072 case 1: /* FALLTHROUGH */
4074 test_true(strncmp(value
, key
, len
) == 0);
4075 test_true(len
== length
);
4078 test_true(length
== len
* 2);
4081 test_true(length
== len
* 3);
4091 /* Try setting an illegal cas value (should not return an error to
4092 * the caller (because we don't expect a return message from the server)
4094 const char* keys
[]= {"0"};
4095 size_t lengths
[]= {1};
4098 memcached_result_st results_obj
;
4099 memcached_result_st
*results
;
4100 test_compare(MEMCACHED_SUCCESS
,
4101 memcached_mget(memc
, keys
, lengths
, 1));
4103 results
= memcached_result_create(memc
, &results_obj
);
4105 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4107 test_compare(MEMCACHED_SUCCESS
, ret
);
4108 uint64_t cas
= memcached_result_cas(results
);
4109 memcached_result_free(&results_obj
);
4111 test_compare(MEMCACHED_SUCCESS
,
4112 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4115 * The item will have a new cas value, so try to set it again with the old
4116 * value. This should fail!
4118 test_compare(MEMCACHED_SUCCESS
,
4119 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4120 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4121 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4122 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4125 return TEST_SUCCESS
;
4128 static test_return_t
analyzer_test(memcached_st
*memc
)
4130 memcached_return_t rc
;
4131 memcached_analysis_st
*report
;
4133 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4134 test_compare(MEMCACHED_SUCCESS
, rc
);
4135 test_true(memc_stat
);
4137 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4138 test_compare(MEMCACHED_SUCCESS
, rc
);
4142 memcached_stat_free(NULL
, memc_stat
);
4144 return TEST_SUCCESS
;
4147 /* Count the objects */
4149 static test_return_t
dump_test(memcached_st
*memc
)
4151 /* No support for Binary protocol yet */
4152 test_skip(false, memc
->flags
.binary_protocol
);
4154 test_compare(TEST_SUCCESS
, set_test3(memc
));
4156 // confirm_key_count() call dump
4157 size_t counter
= confirm_key_count(memc
);
4159 /* We may have more then 32 if our previous flush has not completed */
4160 test_true(counter
>= 32);
4162 return TEST_SUCCESS
;
4165 static test_return_t
util_version_test(memcached_st
*memc
)
4167 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
4168 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
4170 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4172 // We expect failure
4175 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4176 fprintf(stderr
, "\nDumping Server Information\n\n");
4177 memcached_server_fn callbacks
[1];
4179 callbacks
[0]= dump_server_information
;
4180 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4181 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4183 test_true(if_successful
== false);
4185 memcached_server_instance_st instance
=
4186 memcached_server_instance_by_position(memc
, 0);
4188 memcached_version(memc
);
4190 // We only use one binary when we test, so this should be just fine.
4191 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4192 test_true(if_successful
== true);
4194 if (instance
->micro_version
> 0)
4196 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4198 else if (instance
->minor_version
> 0)
4200 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4202 else if (instance
->major_version
> 0)
4204 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4207 test_true(if_successful
== true);
4209 if (instance
->micro_version
> 0)
4211 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4213 else if (instance
->minor_version
> 0)
4215 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4217 else if (instance
->major_version
> 0)
4219 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4222 test_true(if_successful
== false);
4224 return TEST_SUCCESS
;
4227 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4229 memcached_return_t rc
;
4230 memcached_server_instance_st instance
=
4231 memcached_server_instance_by_position(memc
, 0);
4233 // Test both the version that returns a code, and the one that does not.
4234 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4235 memcached_server_port(instance
) -1, NULL
) == -1);
4237 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4238 memcached_server_port(instance
) -1, &rc
) == -1);
4239 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4241 return TEST_SUCCESS
;
4245 static test_return_t
getpid_test(memcached_st
*memc
)
4247 memcached_return_t rc
;
4248 memcached_server_instance_st instance
=
4249 memcached_server_instance_by_position(memc
, 0);
4251 // Test both the version that returns a code, and the one that does not.
4252 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4253 memcached_server_port(instance
), NULL
) > -1);
4255 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4256 memcached_server_port(instance
), &rc
) > -1);
4257 test_compare(MEMCACHED_SUCCESS
, rc
);
4259 return TEST_SUCCESS
;
4262 static test_return_t
ping_test(memcached_st
*memc
)
4264 memcached_return_t rc
;
4265 memcached_server_instance_st instance
=
4266 memcached_server_instance_by_position(memc
, 0);
4268 // Test both the version that returns a code, and the one that does not.
4269 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4270 memcached_server_port(instance
), NULL
));
4272 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4273 memcached_server_port(instance
), &rc
));
4275 test_compare(MEMCACHED_SUCCESS
, rc
);
4277 return TEST_SUCCESS
;
4282 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4286 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4287 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4288 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4289 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4290 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4291 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4292 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4293 #ifdef HAVE_HSIEH_HASH
4294 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4296 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4297 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4298 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4300 return TEST_SUCCESS
;
4304 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4306 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4308 test_compare(MEMCACHED_SUCCESS
,
4309 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4310 (uint64_t)MEMCACHED_HASH_HSIEH
));
4312 return TEST_SUCCESS
;
4315 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4317 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4319 test_compare(MEMCACHED_SUCCESS
,
4320 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
4322 return TEST_SUCCESS
;
4325 static test_return_t
one_at_a_time_run (memcached_st
*)
4330 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4332 test_compare(one_at_a_time_values
[x
],
4333 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
4336 return TEST_SUCCESS
;
4339 static test_return_t
md5_run (memcached_st
*)
4344 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4346 test_compare(md5_values
[x
],
4347 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
4350 return TEST_SUCCESS
;
4353 static test_return_t
crc_run (memcached_st
*)
4358 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4360 test_compare(crc_values
[x
],
4361 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
4364 return TEST_SUCCESS
;
4367 static test_return_t
fnv1_64_run (memcached_st
*)
4369 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
4374 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4376 test_compare(fnv1_64_values
[x
],
4377 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
4380 return TEST_SUCCESS
;
4383 static test_return_t
fnv1a_64_run (memcached_st
*)
4385 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
4390 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4392 test_compare(fnv1a_64_values
[x
],
4393 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
4396 return TEST_SUCCESS
;
4399 static test_return_t
fnv1_32_run (memcached_st
*)
4404 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4406 test_compare(fnv1_32_values
[x
],
4407 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
4410 return TEST_SUCCESS
;
4413 static test_return_t
fnv1a_32_run (memcached_st
*)
4418 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4420 test_compare(fnv1a_32_values
[x
],
4421 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
4424 return TEST_SUCCESS
;
4427 static test_return_t
hsieh_run (memcached_st
*)
4429 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4434 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4436 test_compare(hsieh_values
[x
],
4437 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
4440 return TEST_SUCCESS
;
4443 static test_return_t
murmur_run (memcached_st
*)
4445 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4447 #ifdef WORDS_BIGENDIAN
4448 (void)murmur_values
;
4449 return TEST_SKIPPED
;
4454 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4456 test_compare(murmur_values
[x
],
4457 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
4460 return TEST_SUCCESS
;
4464 static test_return_t
jenkins_run (memcached_st
*)
4469 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4471 test_compare(jenkins_values
[x
],
4472 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
4475 return TEST_SUCCESS
;
4478 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
4480 return libhashkit_md5(string
, string_length
);
4483 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
4485 return libhashkit_crc32(string
, string_length
);
4488 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4494 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5"));
4496 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};
4497 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};
4499 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4501 hashkit_clone(&new_kit
, kit
);
4502 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4504 memcached_set_hashkit(memc
, &new_kit
);
4507 Verify Setting the hash.
4509 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4513 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4514 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4519 Now check memcached_st.
4521 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4525 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4526 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4529 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4531 memcached_set_hashkit(memc
, &new_kit
);
4534 Verify Setting the hash.
4536 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4540 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4541 test_true(crc_values
[x
] == hash_val
);
4544 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4548 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4549 test_compare(crc_hosts
[x
], hash_val
);
4552 memcached_free(memc
);
4554 return TEST_SUCCESS
;
4558 Test case adapted from John Gorman <johngorman2@gmail.com>
4560 We are testing the error condition when we connect to a server via memcached_get()
4561 but find that the server is not available.
4563 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4565 const char *key
= "MemcachedLives";
4568 memcached_return rc
;
4571 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4573 // See if memcached is reachable.
4574 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4578 test_true(memcached_failed(rc
));
4580 memcached_free(tl_memc_h
);
4582 return TEST_SUCCESS
;
4586 We connect to a server which exists, but search for a key that does not exist.
4588 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4590 const char *key
= "MemcachedKeyNotEXIST";
4593 memcached_return rc
;
4595 // See if memcached is reachable.
4596 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4600 test_compare(MEMCACHED_NOTFOUND
, rc
);
4602 return TEST_SUCCESS
;
4606 Test case adapted from John Gorman <johngorman2@gmail.com>
4608 We are testing the error condition when we connect to a server via memcached_get_by_key()
4609 but find that the server is not available.
4611 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4614 memcached_st
*tl_memc_h
;
4615 memcached_server_st
*servers
;
4617 const char *key
= "MemcachedLives";
4620 memcached_return rc
;
4624 tl_memc_h
= memcached_create(NULL
);
4625 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4626 memcached_server_push(tl_memc_h
, servers
);
4627 memcached_server_list_free(servers
);
4629 // See if memcached is reachable.
4630 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4634 test_true(memcached_failed(rc
));
4636 memcached_free(tl_memc_h
);
4638 return TEST_SUCCESS
;
4642 We connect to a server which exists, but search for a key that does not exist.
4644 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4646 const char *key
= "MemcachedKeyNotEXIST";
4649 memcached_return rc
;
4652 // See if memcached is reachable.
4653 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4657 test_compare(MEMCACHED_NOTFOUND
, rc
);
4659 return TEST_SUCCESS
;
4662 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4664 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4666 const char *key
= "regression_bug_434484";
4667 size_t keylen
= strlen(key
);
4669 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4670 test_compare(MEMCACHED_NOTSTORED
, ret
);
4672 size_t size
= 2048 * 1024;
4673 char *data
= (char*)calloc(1, size
);
4675 test_compare(MEMCACHED_E2BIG
,
4676 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4679 return TEST_SUCCESS
;
4682 static test_return_t
regression_bug_434843(memcached_st
*memc
)
4684 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4686 memcached_return_t rc
;
4688 memcached_execute_fn callbacks
[]= { &callback_counter
};
4691 * I only want to hit only _one_ server so I know the number of requests I'm
4692 * sending in the pipleine to the server. Let's try to do a multiget of
4693 * 1024 (that should satisfy most users don't you think?). Future versions
4694 * will include a mget_execute function call if you need a higher number.
4696 uint32_t number_of_hosts
= memcached_server_count(memc
);
4697 memc
->number_of_hosts
= 1;
4698 const size_t max_keys
= 1024;
4699 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4700 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4702 for (size_t x
= 0; x
< max_keys
; ++x
)
4706 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4712 * Run two times.. the first time we should have 100% cache miss,
4713 * and the second time we should have 100% cache hits
4715 for (size_t y
= 0; y
< 2; y
++)
4717 test_compare(MEMCACHED_SUCCESS
,
4718 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4720 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4721 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4725 /* The first iteration should give me a 100% cache miss. verify that*/
4726 char blob
[1024]= { 0 };
4728 test_false(counter
);
4730 for (size_t x
= 0; x
< max_keys
; ++x
)
4732 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4733 blob
, sizeof(blob
), 0, 0);
4734 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4739 /* Verify that we received all of the key/value pairs */
4740 test_compare(counter
, max_keys
);
4744 /* Release allocated resources */
4745 for (size_t x
= 0; x
< max_keys
; ++x
)
4752 memc
->number_of_hosts
= number_of_hosts
;
4754 return TEST_SUCCESS
;
4757 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4759 memcached_return_t rc
;
4760 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4761 test_compare(MEMCACHED_SUCCESS
, rc
);
4763 return regression_bug_434843(memc
);
4766 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4768 memcached_return_t rc
;
4769 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4770 test_compare(MEMCACHED_SUCCESS
, rc
);
4772 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4773 test_compare(MEMCACHED_SUCCESS
, rc
);
4774 test_true(bytes_str
);
4775 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4777 test_compare(MEMCACHED_SUCCESS
, rc
);
4778 test_true(bytes_read_str
);
4780 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4781 "bytes_written", &rc
);
4782 test_compare(MEMCACHED_SUCCESS
, rc
);
4783 test_true(bytes_written_str
);
4785 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4786 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4787 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4789 test_true(bytes
!= bytes_read
);
4790 test_true(bytes
!= bytes_written
);
4792 /* Release allocated resources */
4794 free(bytes_read_str
);
4795 free(bytes_written_str
);
4796 memcached_stat_free(NULL
, memc_stat
);
4798 return TEST_SUCCESS
;
4802 * The test case isn't obvious so I should probably document why
4803 * it works the way it does. Bug 442914 was caused by a bug
4804 * in the logic in memcached_purge (it did not handle the case
4805 * where the number of bytes sent was equal to the watermark).
4806 * In this test case, create messages so that we hit that case
4807 * and then disable noreply mode and issue a new command to
4808 * verify that it isn't stuck. If we change the format for the
4809 * delete command or the watermarks, we need to update this
4812 static test_return_t
regression_bug_442914(memcached_st
*memc
)
4814 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4815 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4817 uint32_t number_of_hosts
= memcached_server_count(memc
);
4818 memc
->number_of_hosts
= 1;
4823 for (uint32_t x
= 0; x
< 250; ++x
)
4825 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4826 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4827 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4830 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
4833 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4834 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4836 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4837 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
4839 memc
->number_of_hosts
= number_of_hosts
;
4841 return TEST_SUCCESS
;
4844 static test_return_t
regression_bug_447342(memcached_st
*memc
)
4846 memcached_server_instance_st instance_one
;
4847 memcached_server_instance_st instance_two
;
4849 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4850 return TEST_SKIPPED
;
4852 test_compare(MEMCACHED_SUCCESS
,
4853 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4855 const unsigned int max_keys
= 100;
4856 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4857 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4859 for (unsigned int x
= 0; x
< max_keys
; ++x
)
4863 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4866 test_compare(MEMCACHED_SUCCESS
,
4867 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
4871 ** We are using the quiet commands to store the replicas, so we need
4872 ** to ensure that all of them are processed before we can continue.
4873 ** In the test we go directly from storing the object to trying to
4874 ** receive the object from all of the different servers, so we
4875 ** could end up in a race condition (the memcached server hasn't yet
4876 ** processed the quiet command from the replication set when it process
4877 ** the request from the other client (created by the clone)). As a
4878 ** workaround for that we call memcached_quit to send the quit command
4879 ** to the server and wait for the response ;-) If you use the test code
4880 ** as an example for your own code, please note that you shouldn't need
4883 memcached_quit(memc
);
4885 /* Verify that all messages are stored, and we didn't stuff too much
4888 test_compare(MEMCACHED_SUCCESS
,
4889 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4891 unsigned int counter
= 0;
4892 memcached_execute_fn callbacks
[]= { &callback_counter
};
4893 test_compare(MEMCACHED_SUCCESS
,
4894 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4896 /* Verify that we received all of the key/value pairs */
4897 test_compare(counter
, max_keys
);
4899 memcached_quit(memc
);
4901 * Don't do the following in your code. I am abusing the internal details
4902 * within the library, and this is not a supported interface.
4903 * This is to verify correct behavior in the library. Fake that two servers
4906 instance_one
= memcached_server_instance_by_position(memc
, 0);
4907 instance_two
= memcached_server_instance_by_position(memc
, 2);
4908 in_port_t port0
= instance_one
->port
;
4909 in_port_t port2
= instance_two
->port
;
4911 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4912 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4914 test_compare(MEMCACHED_SUCCESS
,
4915 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4918 test_compare(MEMCACHED_SUCCESS
,
4919 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4920 test_compare(counter
, (unsigned int)max_keys
);
4922 /* restore the memc handle */
4923 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4924 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4926 memcached_quit(memc
);
4928 /* Remove half of the objects */
4929 for (size_t x
= 0; x
< max_keys
; ++x
)
4933 test_compare(MEMCACHED_SUCCESS
,
4934 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
4938 memcached_quit(memc
);
4939 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4940 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4942 /* now retry the command, this time we should have cache misses */
4943 test_compare(MEMCACHED_SUCCESS
,
4944 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4947 test_compare(MEMCACHED_SUCCESS
,
4948 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4949 test_compare(counter
, (unsigned int)(max_keys
>> 1));
4951 /* Release allocated resources */
4952 for (size_t x
= 0; x
< max_keys
; ++x
)
4959 /* restore the memc handle */
4960 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4961 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4963 return TEST_SUCCESS
;
4966 static test_return_t
regression_bug_463297(memcached_st
*memc
)
4968 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4969 test_true(memc_clone
);
4970 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4972 memcached_server_instance_st instance
=
4973 memcached_server_instance_by_position(memc_clone
, 0);
4975 if (instance
->major_version
> 1 ||
4976 (instance
->major_version
== 1 &&
4977 instance
->minor_version
> 2))
4979 /* Binary protocol doesn't support deferred delete */
4980 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4981 test_true(bin_clone
);
4982 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4983 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4984 memcached_free(bin_clone
);
4986 memcached_quit(memc_clone
);
4988 /* If we know the server version, deferred delete should fail
4989 * with invalid arguments */
4990 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4992 /* If we don't know the server version, we should get a protocol error */
4993 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4995 /* but there is a bug in some of the memcached servers (1.4) that treats
4996 * the counter as noreply so it doesn't send the proper error message
4998 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5000 /* And buffered mode should be disabled and we should get protocol error */
5001 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5002 rc
= memcached_delete(memc
, "foo", 3, 1);
5003 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5005 /* Same goes for noreply... */
5006 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5007 rc
= memcached_delete(memc
, "foo", 3, 1);
5008 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5010 /* but a normal request should go through (and be buffered) */
5011 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
5012 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
5014 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
5015 /* unbuffered noreply should be success */
5016 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
5017 /* unbuffered with reply should be not found... */
5018 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5019 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
5022 memcached_free(memc_clone
);
5023 return TEST_SUCCESS
;
5027 /* Test memcached_server_get_last_disconnect
5028 * For a working server set, shall be NULL
5029 * For a set of non existing server, shall not be NULL
5031 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5033 memcached_return_t rc
;
5034 memcached_server_instance_st disconnected_server
;
5036 /* With the working set of server */
5037 const char *key
= "marmotte";
5038 const char *value
= "milka";
5040 memcached_reset_last_disconnected_server(memc
);
5041 test_false(memc
->last_disconnected_server
);
5042 rc
= memcached_set(memc
, key
, strlen(key
),
5043 value
, strlen(value
),
5044 (time_t)0, (uint32_t)0);
5045 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5047 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5048 test_false(disconnected_server
);
5050 /* With a non existing server */
5052 memcached_server_st
*servers
;
5054 const char *server_list
= "localhost:9";
5056 servers
= memcached_servers_parse(server_list
);
5058 mine
= memcached_create(NULL
);
5059 rc
= memcached_server_push(mine
, servers
);
5060 test_compare(MEMCACHED_SUCCESS
, rc
);
5061 memcached_server_list_free(servers
);
5064 rc
= memcached_set(mine
, key
, strlen(key
),
5065 value
, strlen(value
),
5066 (time_t)0, (uint32_t)0);
5067 test_true(memcached_failed(rc
));
5069 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5070 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5071 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5072 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5074 memcached_quit(mine
);
5075 memcached_free(mine
);
5077 return TEST_SUCCESS
;
5080 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5082 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5083 char buffer
[BUFSIZ
];
5085 test_compare(MEMCACHED_SUCCESS
,
5086 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5088 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5091 // We will just use the error strings as our keys
5092 uint32_t counter
= 100;
5095 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5097 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5098 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5099 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
5101 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5102 test_true(disconnected_server
);
5103 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5104 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5108 memcached_reset_last_disconnected_server(memc
);
5113 memcached_free(memc
);
5115 return TEST_SUCCESS
;
5118 static test_return_t
test_verbosity(memcached_st
*memc
)
5120 memcached_verbosity(memc
, 3);
5122 return TEST_SUCCESS
;
5126 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5127 const char *key
, size_t key_length
,
5128 const char *value
, size_t value_length
,
5138 return MEMCACHED_SUCCESS
;
5141 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5143 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5144 test_compare(MEMCACHED_SUCCESS
, rc
);
5146 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5147 test_compare(MEMCACHED_SUCCESS
, rc
);
5149 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5150 test_compare(MEMCACHED_SUCCESS
, rc
);
5152 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5153 test_compare(MEMCACHED_SUCCESS
, rc
);
5155 return TEST_SUCCESS
;
5159 * This test ensures that the failure counter isn't incremented during
5160 * normal termination of the memcached instance.
5162 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5164 memcached_return_t rc
;
5165 memcached_server_instance_st instance
;
5167 /* Set value to force connection to the server */
5168 const char *key
= "marmotte";
5169 const char *value
= "milka";
5172 * Please note that I'm abusing the internal structures in libmemcached
5173 * in a non-portable way and you shouldn't be doing this. I'm only
5174 * doing this in order to verify that the library works the way it should
5176 uint32_t number_of_hosts
= memcached_server_count(memc
);
5177 memc
->number_of_hosts
= 1;
5179 /* Ensure that we are connected to the server by setting a value */
5180 rc
= memcached_set(memc
, key
, strlen(key
),
5181 value
, strlen(value
),
5182 (time_t)0, (uint32_t)0);
5183 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5186 instance
= memcached_server_instance_by_position(memc
, 0);
5187 /* The test is to see that the memcached_quit doesn't increase the
5188 * the server failure conter, so let's ensure that it is zero
5189 * before sending quit
5191 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5193 memcached_quit(memc
);
5195 /* Verify that it memcached_quit didn't increment the failure counter
5196 * Please note that this isn't bullet proof, because an error could
5199 test_zero(instance
->server_failure_counter
);
5201 /* restore the instance */
5202 memc
->number_of_hosts
= number_of_hosts
;
5204 return TEST_SUCCESS
;
5208 * This tests ensures expected disconnections (for some behavior changes
5209 * for instance) do not wrongly increase failure counter
5211 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5213 memcached_return rc
;
5215 memcached_st
*memc_clone
;
5216 memc_clone
= memcached_clone(NULL
, memc
);
5217 test_true(memc_clone
);
5219 /* Set value to force connection to the server */
5220 const char *key
= "marmotte";
5221 const char *value
= "milka";
5222 char *string
= NULL
;
5223 size_t string_length
;
5226 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5227 value
, strlen(value
),
5228 (time_t)0, (uint32_t)0);
5229 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5232 /* put failure limit to 1 */
5233 test_compare(MEMCACHED_SUCCESS
,
5234 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1));
5236 /* Put a retry timeout to effectively activate failure_limit effect */
5237 test_compare(MEMCACHED_SUCCESS
,
5238 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
5240 /* change behavior that triggers memcached_quit()*/
5241 test_compare(MEMCACHED_SUCCESS
,
5242 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5245 /* Check if we still are connected */
5246 string
= memcached_get(memc_clone
, key
, strlen(key
),
5247 &string_length
, &flags
, &rc
);
5249 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5252 memcached_free(memc_clone
);
5254 return TEST_SUCCESS
;
5261 * Test that ensures mget_execute does not end into recursive calls that finally fails
5263 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5265 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5266 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5267 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5268 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5269 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5272 return TEST_SKIPPED
; // My MAC can't handle this test
5276 * I only want to hit _one_ server so I know the number of requests I'm
5277 * sending in the pipeline.
5279 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5280 memc
->number_of_hosts
= 1;
5281 size_t max_keys
= 20480;
5284 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5285 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5287 /* First add all of the items.. */
5288 char blob
[1024]= { 0 };
5289 for (size_t x
= 0; x
< max_keys
; ++x
)
5292 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5295 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5296 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5301 /* Try to get all of them with a large multiget */
5303 memcached_execute_function callbacks
[]= { &callback_counter
};
5304 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5305 (size_t)max_keys
, callbacks
, &counter
, 1);
5306 test_compare(MEMCACHED_SUCCESS
, rc
);
5308 char* the_value
= NULL
;
5309 char the_key
[MEMCACHED_MAX_KEY
];
5310 size_t the_key_length
;
5311 size_t the_value_length
;
5315 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5317 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5323 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5326 test_compare(MEMCACHED_END
, rc
);
5328 /* Verify that we got all of the items */
5329 test_compare(counter
, max_keys
);
5332 /* Release all allocated resources */
5333 for (size_t x
= 0; x
< max_keys
; ++x
)
5340 memc
->number_of_hosts
= number_of_hosts
;
5342 return TEST_SUCCESS
;
5345 static test_return_t
regression_bug_583031(memcached_st
*)
5347 memcached_st
*memc
= memcached_create(NULL
);
5349 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5351 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5352 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5353 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5354 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5355 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5356 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5358 memcached_return_t rc
;
5362 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5366 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5368 memcached_free(memc
);
5370 return TEST_SUCCESS
;
5373 static test_return_t
regression_bug_581030(memcached_st
*)
5376 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5377 test_false(local_stat
);
5379 memcached_stat_free(NULL
, NULL
);
5382 return TEST_SUCCESS
;
5385 #define regression_bug_655423_COUNT 6000
5386 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5388 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5389 memc
= NULL
; // Just to make sure it is not used
5394 return TEST_SKIPPED
;
5397 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5398 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5399 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5400 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5402 memset(payload
, int('x'), sizeof(payload
));
5404 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5406 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5407 snprintf(key
, sizeof(key
), "%u", x
);
5409 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5412 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5414 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5415 snprintf(key
, sizeof(key
), "%u", x
);
5417 size_t value_length
;
5418 memcached_return_t rc
;
5419 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5421 if (rc
== MEMCACHED_NOTFOUND
)
5424 test_zero(value_length
);
5428 test_compare(MEMCACHED_SUCCESS
, rc
);
5430 test_compare(100LLU, value_length
);
5434 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5435 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5436 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5438 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5439 snprintf(key
, sizeof(key
), "%u", x
);
5441 keys
[x
]= strdup(key
);
5443 key_length
[x
]= strlen(key
);
5444 test_true(key_length
[x
]);
5447 test_compare(MEMCACHED_SUCCESS
,
5448 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5451 memcached_result_st
*result
= NULL
;
5452 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5454 test_compare(size_t(100), memcached_result_length(result
));
5458 test_true(count
> 100); // If we don't get back atleast this, something is up
5460 /* Release all allocated resources */
5461 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5469 memcached_free(clone
);
5471 return TEST_SUCCESS
;
5475 * Test that ensures that buffered set to not trigger problems during io_flush
5477 #define regression_bug_490520_COUNT 200480
5478 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5480 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5481 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5482 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5483 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5484 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5486 memc
->number_of_hosts
= 1;
5488 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5489 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5491 /* First add all of the items.. */
5492 char blob
[3333] = {0};
5493 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5496 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5500 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5501 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5504 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5511 return TEST_SUCCESS
;
5515 static test_return_t
regression_bug_854604(memcached_st
*)
5519 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
5521 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
5523 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
5524 test_compare(buffer
[0], 0);
5526 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
5527 test_true(strlen(buffer
));
5529 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
5530 test_true(strlen(buffer
));
5532 return TEST_SUCCESS
;
5535 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5537 fprintf(stderr
, "Iteration #%u: ", it
);
5539 if (error
== MEMCACHED_ERRNO
)
5541 fprintf(stderr
, "system error %d from %s: %s\n",
5542 errno
, what
, strerror(errno
));
5546 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5547 memcached_strerror(mc
, error
));
5551 #define TEST_CONSTANT_CREATION 200
5553 static test_return_t
regression_bug_(memcached_st
*memc
)
5555 const char *remote_server
;
5558 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5560 return TEST_SKIPPED
;
5563 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5565 memcached_st
* mc
= memcached_create(NULL
);
5566 memcached_return rc
;
5568 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5569 if (rc
!= MEMCACHED_SUCCESS
)
5571 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5574 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5575 if (rc
!= MEMCACHED_SUCCESS
)
5577 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5580 rc
= memcached_server_add(mc
, remote_server
, 0);
5581 if (rc
!= MEMCACHED_SUCCESS
)
5583 memcached_die(mc
, rc
, "memcached_server_add", x
);
5586 const char *set_key
= "akey";
5587 const size_t set_key_len
= strlen(set_key
);
5588 const char *set_value
= "a value";
5589 const size_t set_value_len
= strlen(set_value
);
5591 if (rc
== MEMCACHED_SUCCESS
)
5595 size_t get_value_len
;
5597 uint32_t get_value_flags
;
5599 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5600 &get_value_flags
, &rc
);
5601 if (rc
!= MEMCACHED_SUCCESS
)
5603 memcached_die(mc
, rc
, "memcached_get", x
);
5609 (get_value_len
!= set_value_len
5610 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5612 fprintf(stderr
, "Values don't match?\n");
5613 rc
= MEMCACHED_FAILURE
;
5619 rc
= memcached_set(mc
,
5620 set_key
, set_key_len
,
5621 set_value
, set_value_len
,
5625 if (rc
!= MEMCACHED_SUCCESS
)
5627 memcached_die(mc
, rc
, "memcached_set", x
);
5634 if (rc
!= MEMCACHED_SUCCESS
)
5640 return TEST_SUCCESS
;
5643 /* Clean the server before beginning testing */
5645 {"util_version", true, (test_callback_fn
*)util_version_test
},
5646 {"flush", false, (test_callback_fn
*)flush_test
},
5647 {"init", false, (test_callback_fn
*)init_test
},
5648 {"allocation", false, (test_callback_fn
*)allocation_test
},
5649 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5650 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5651 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5652 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5653 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5654 {"clone_test", false, (test_callback_fn
*)clone_test
},
5655 {"connection_test", false, (test_callback_fn
*)connection_test
},
5656 {"callback_test", false, (test_callback_fn
*)callback_test
},
5657 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5658 {"set", false, (test_callback_fn
*)set_test
},
5659 {"set2", false, (test_callback_fn
*)set_test2
},
5660 {"set3", false, (test_callback_fn
*)set_test3
},
5661 {"dump", true, (test_callback_fn
*)dump_test
},
5662 {"add", true, (test_callback_fn
*)add_test
},
5663 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5664 {"replace", true, (test_callback_fn
*)replace_test
},
5665 {"delete", true, (test_callback_fn
*)delete_test
},
5666 {"get", true, (test_callback_fn
*)get_test
},
5667 {"get2", false, (test_callback_fn
*)get_test2
},
5668 {"get3", false, (test_callback_fn
*)get_test3
},
5669 {"get4", false, (test_callback_fn
*)get_test4
},
5670 {"partial mget", false, (test_callback_fn
*)get_test5
},
5671 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5672 {"increment", false, (test_callback_fn
*)increment_test
},
5673 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5674 {"decrement", false, (test_callback_fn
*)decrement_test
},
5675 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5676 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5677 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5678 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5679 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5680 {"binary_increment_with_prefix", 1, (test_callback_fn
*)binary_increment_with_prefix_test
},
5681 {"quit", false, (test_callback_fn
*)quit_test
},
5682 {"mget", true, (test_callback_fn
*)mget_test
},
5683 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5684 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5685 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5686 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5687 {"mget_end", false, (test_callback_fn
*)mget_end
},
5688 {"get_stats", false, (test_callback_fn
*)get_stats
},
5689 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5690 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5691 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5692 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
5693 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5694 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5695 {"read_through", true, (test_callback_fn
*)read_through
},
5696 {"delete_through", true, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER
},
5697 {"noreply", true, (test_callback_fn
*)noreply_test
},
5698 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5699 {"memcached_pool_st", true, (test_callback_fn
*)connection_pool_test
},
5700 {"memcached_pool_st #2", true, (test_callback_fn
*)connection_pool2_test
},
5701 {"memcached_pool_st #3", true, (test_callback_fn
*)connection_pool3_test
},
5702 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
5703 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
5704 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
5705 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
5706 {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_NOTFOUND
},
5707 {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_SUCCESS
},
5708 {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_by_key_NOTFOUND
},
5709 {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_by_key_SUCCESS
},
5710 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5711 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5715 test_st touch_tests
[] ={
5716 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5717 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5721 test_st behavior_tests
[] ={
5722 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5723 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5724 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5725 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5726 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5727 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5728 {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test
},
5729 {"MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY", false, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY
},
5733 test_st libmemcachedutil_tests
[] ={
5734 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5735 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5736 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5740 test_st basic_tests
[] ={
5741 {"init", true, (test_callback_fn
*)basic_init_test
},
5742 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5743 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5744 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5745 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5746 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5747 {"memcached_return_t", false, (test_callback_fn
*)memcached_return_t_TEST
},
5751 test_st regression_binary_vs_block
[] ={
5752 {"block add", true, (test_callback_fn
*)block_add_regression
},
5753 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
5757 test_st async_tests
[] ={
5758 {"add", true, (test_callback_fn
*)add_wrapper
},
5762 test_st memcached_server_get_last_disconnect_tests
[] ={
5763 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
5764 {0, 0, (test_callback_fn
*)0}
5768 test_st result_tests
[] ={
5769 {"result static", false, (test_callback_fn
*)result_static
},
5770 {"result alloc", false, (test_callback_fn
*)result_alloc
},
5771 {0, 0, (test_callback_fn
*)0}
5774 test_st version_1_2_3
[] ={
5775 {"append", false, (test_callback_fn
*)append_test
},
5776 {"prepend", false, (test_callback_fn
*)prepend_test
},
5777 {"cas", false, (test_callback_fn
*)cas_test
},
5778 {"cas2", false, (test_callback_fn
*)cas2_test
},
5779 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
5780 {0, 0, (test_callback_fn
*)0}
5783 test_st haldenbrand_tests
[] ={
5784 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
5785 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
5786 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
5787 {0, 0, (test_callback_fn
*)0}
5790 test_st user_tests
[] ={
5791 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
5792 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
5793 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
5794 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
5795 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
5796 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
5797 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
5798 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
5799 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
5800 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
5801 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
5802 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
5803 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
5804 #if !defined(__sun) && !defined(__OpenBSD__)
5806 ** It seems to be something weird with the character sets..
5807 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5808 ** guess I need to find out how this is supposed to work.. Perhaps I need
5809 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5810 ** so just disable the code for now...).
5812 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
5814 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
5815 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
5816 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
5817 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
5818 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
5819 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
5820 {0, 0, (test_callback_fn
*)0}
5823 test_st replication_tests
[]= {
5824 {"set", true, (test_callback_fn
*)replication_set_test
},
5825 {"get", false, (test_callback_fn
*)replication_get_test
},
5826 {"mget", false, (test_callback_fn
*)replication_mget_test
},
5827 {"delete", true, (test_callback_fn
*)replication_delete_test
},
5828 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
5829 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
5830 {0, 0, (test_callback_fn
*)0}
5834 * The following test suite is used to verify that we don't introduce
5835 * regression bugs. If you want more information about the bug / test,
5836 * you should look in the bug report at
5837 * http://bugs.launchpad.net/libmemcached
5839 test_st regression_tests
[]= {
5840 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
5841 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
5842 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
5843 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
5844 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
5845 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
5846 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
5847 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
5848 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
5849 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
5850 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
5851 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
5852 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
5853 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
5854 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
5855 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
5856 {"lp:854604", true, (test_callback_fn
*)regression_bug_854604
},
5857 {0, false, (test_callback_fn
*)0}
5860 test_st ketama_compatibility
[]= {
5861 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
5862 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
5863 {0, 0, (test_callback_fn
*)0}
5866 test_st generate_tests
[] ={
5867 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5868 {"generate_data", true, (test_callback_fn
*)generate_data
},
5869 {"get_read", false, (test_callback_fn
*)get_read
},
5870 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
5871 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5872 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
5873 {"generate_data", true, (test_callback_fn
*)generate_data
},
5874 {"mget_read", false, (test_callback_fn
*)mget_read
},
5875 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
5876 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
5877 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
5878 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
5879 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5880 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
5881 {"generate_data", true, (test_callback_fn
*)generate_data
},
5882 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5883 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5884 {0, 0, (test_callback_fn
*)0}
5887 test_st consistent_tests
[] ={
5888 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5889 {"generate_data", true, (test_callback_fn
*)generate_data
},
5890 {"get_read", 0, (test_callback_fn
*)get_read_count
},
5891 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5892 {0, 0, (test_callback_fn
*)0}
5895 test_st consistent_weighted_tests
[] ={
5896 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5897 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
5898 {"get_read", false, (test_callback_fn
*)get_read_count
},
5899 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5900 {0, 0, (test_callback_fn
*)0}
5903 test_st hsieh_availability
[] ={
5904 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
5905 {0, 0, (test_callback_fn
*)0}
5908 test_st murmur_availability
[] ={
5909 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
5910 {0, 0, (test_callback_fn
*)0}
5914 test_st hash_sanity
[] ={
5915 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
5916 {0, 0, (test_callback_fn
*)0}
5920 test_st ketama_auto_eject_hosts
[] ={
5921 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
5922 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
5923 {0, 0, (test_callback_fn
*)0}
5926 test_st hash_tests
[] ={
5927 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
5928 {"md5", false, (test_callback_fn
*)md5_run
},
5929 {"crc", false, (test_callback_fn
*)crc_run
},
5930 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
5931 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
5932 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
5933 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
5934 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
5935 {"murmur", false, (test_callback_fn
*)murmur_run
},
5936 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
5937 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
5938 {0, 0, (test_callback_fn
*)0}
5941 test_st error_conditions
[] ={
5942 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
5943 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
5944 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
5945 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5946 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5947 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
5948 {0, 0, (test_callback_fn
*)0}
5951 test_st parser_tests
[] ={
5952 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
5953 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
5954 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
5955 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
5956 {"hash", false, (test_callback_fn
*)parser_hash_test
},
5957 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
5958 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
5959 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
5960 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
5961 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
5962 {"server", false, (test_callback_fn
*)server_test
},
5963 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
5964 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
5965 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
5966 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
5967 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
5968 {0, 0, (test_callback_fn
*)0}
5971 test_st virtual_bucket_tests
[] ={
5972 {"basic", false, (test_callback_fn
*)virtual_back_map
},
5973 {0, 0, (test_callback_fn
*)0}
5976 test_st memcached_server_add_tests
[] ={
5977 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
5978 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
5979 {0, 0, (test_callback_fn
*)0}
5982 test_st namespace_tests
[] ={
5983 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
5984 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
5985 {0, 0, (test_callback_fn
*)0}
5988 collection_st collection
[] ={
5990 {"hash_sanity", 0, 0, hash_sanity
},
5992 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
5993 {"basic", 0, 0, basic_tests
},
5994 {"hsieh_availability", 0, 0, hsieh_availability
},
5995 {"murmur_availability", 0, 0, murmur_availability
},
5996 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
5997 {"block", 0, 0, tests
},
5998 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
5999 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
6000 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6001 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
6002 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
6003 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
6004 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
6005 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
6006 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
6007 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
6008 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
6009 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
6010 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
6011 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6012 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
6013 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6014 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
6015 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
6016 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
6017 #ifdef MEMCACHED_ENABLE_DEPRECATED
6018 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
6020 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
6021 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
6022 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
6023 {"specific namespace", 0, 0, namespace_tests
},
6024 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
6025 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
6026 {"result", 0, 0, result_tests
},
6027 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
6028 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
6029 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
6030 {"user written tests", 0, 0, user_tests
},
6031 {"generate", 0, 0, generate_tests
},
6032 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
6033 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
6034 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
6035 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
6036 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
6037 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
6038 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
6040 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
6041 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
6042 {"consistent_not", 0, 0, consistent_tests
},
6043 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
6044 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6045 {"ketama_compat", 0, 0, ketama_compatibility
},
6046 {"test_hashes", 0, 0, hash_tests
},
6047 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6048 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6049 {"regression", 0, 0, regression_tests
},
6050 {"behaviors", 0, 0, behavior_tests
},
6051 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6052 {"error_conditions", 0, 0, error_conditions
},
6053 {"parser", 0, 0, parser_tests
},
6054 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6055 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6056 {"touch", 0, 0, touch_tests
},
6060 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
6062 #include "tests/libmemcached_world.h"
6064 void get_world(Framework
*world
)
6066 world
->collections
= collection
;
6068 world
->_create
= (test_callback_create_fn
*)world_create
;
6069 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6071 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6072 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6073 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6074 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6075 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6077 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6078 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6080 world
->set_runner(&defualt_libmemcached_runner
);
6082 world
->set_socket();