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 "tests/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
= GLOBAL2_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 test_skip(true, libmemcached_util_version_check(memc
, 1, 4, 4));
110 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
115 static memcached_return_t
return_value_based_on_buffering(memcached_st
*memc
)
117 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
))
119 return MEMCACHED_BUFFERED
;
122 return MEMCACHED_SUCCESS
;
125 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
128 * I only want to hit _one_ server so I know the number of requests I'm
129 * sending in the pipeline.
131 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
133 char server_string
[1024];
134 int server_string_length
;
137 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
138 memcached_server_name(instance
), int(memcached_server_port(instance
)),
143 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
144 memcached_server_name(instance
), int(memcached_server_port(instance
)));
147 if (server_string_length
<= 0)
153 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, buffer
, sizeof(buffer
))))
155 Error
<< "Failed to parse " << server_string_length
;
159 return memcached(server_string
, server_string_length
);
163 static test_return_t
init_test(memcached_st
*not_used
)
168 (void)memcached_create(&memc
);
169 memcached_free(&memc
);
174 #define TEST_PORT_COUNT 7
175 in_port_t test_ports
[TEST_PORT_COUNT
];
177 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
178 const memcached_server_st
*server
,
182 size_t bigger
= *((size_t *)(context
));
184 assert(bigger
<= memcached_server_port(server
));
185 *((size_t *)(context
))= memcached_server_port(server
);
187 return MEMCACHED_SUCCESS
;
190 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
191 const memcached_server_st
*instance
,
195 FILE *stream
= (FILE *)context
;
198 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
199 memcached_server_name(instance
),
200 memcached_server_port(instance
),
201 instance
->major_version
,
202 instance
->minor_version
,
203 instance
->micro_version
);
205 return MEMCACHED_SUCCESS
;
208 static test_return_t
server_sort_test(memcached_st
*ptr
)
210 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
212 memcached_return_t rc
;
213 memcached_server_fn callbacks
[1];
214 memcached_st
*local_memc
;
217 local_memc
= memcached_create(NULL
);
218 test_true(local_memc
);
219 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
221 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
223 test_ports
[x
]= (in_port_t
)random() % 64000;
224 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
225 test_compare(memcached_server_count(local_memc
), x
+1);
227 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
229 test_compare(MEMCACHED_SUCCESS
, rc
);
232 callbacks
[0]= server_display_function
;
233 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
236 memcached_free(local_memc
);
241 static test_return_t
server_sort2_test(memcached_st
*ptr
)
243 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
244 memcached_server_fn callbacks
[1];
245 memcached_st
*local_memc
;
246 memcached_server_instance_st instance
;
249 local_memc
= memcached_create(NULL
);
250 test_true(local_memc
);
251 test_compare(MEMCACHED_SUCCESS
,
252 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
254 test_compare(MEMCACHED_SUCCESS
,
255 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
256 instance
= memcached_server_instance_by_position(local_memc
, 0);
257 test_compare(in_port_t(43043), memcached_server_port(instance
));
259 test_compare(MEMCACHED_SUCCESS
,
260 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
262 instance
= memcached_server_instance_by_position(local_memc
, 0);
263 test_compare(in_port_t(43042), memcached_server_port(instance
));
265 instance
= memcached_server_instance_by_position(local_memc
, 1);
266 test_compare(in_port_t(43043), memcached_server_port(instance
));
268 callbacks
[0]= server_display_function
;
269 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
272 memcached_free(local_memc
);
277 static test_return_t
memcached_server_remove_test(memcached_st
*)
279 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";
282 test_compare(MEMCACHED_SUCCESS
,
283 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
284 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
287 memcached_server_fn callbacks
[1];
288 callbacks
[0]= server_print_callback
;
289 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
291 memcached_free(memc
);
296 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
297 const memcached_server_st
*server
,
301 uint32_t x
= *((uint32_t *)(context
));
303 if (! (test_ports
[x
] == server
->port
))
305 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
306 return MEMCACHED_FAILURE
;
309 *((uint32_t *)(context
))= ++x
;
311 return MEMCACHED_SUCCESS
;
314 static test_return_t
server_unsort_test(memcached_st
*ptr
)
316 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
317 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
318 memcached_server_fn callbacks
[1];
319 memcached_st
*local_memc
;
322 local_memc
= memcached_create(NULL
);
323 test_true(local_memc
);
325 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
327 test_ports
[x
]= (in_port_t
)(random() % 64000);
328 test_compare(MEMCACHED_SUCCESS
,
329 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
330 test_compare(memcached_server_count(local_memc
), x
+1);
332 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
336 callbacks
[0]= server_display_unsort_function
;
337 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
339 /* Now we sort old data! */
340 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
341 callbacks
[0]= server_display_function
;
342 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
345 memcached_free(local_memc
);
350 static test_return_t
allocation_test(memcached_st
*not_used
)
354 memc
= memcached_create(NULL
);
356 memcached_free(memc
);
361 static test_return_t
clone_test(memcached_st
*memc
)
365 memcached_st
*memc_clone
;
366 memc_clone
= memcached_clone(NULL
, NULL
);
367 test_true(memc_clone
);
368 memcached_free(memc_clone
);
371 /* Can we init from null? */
373 memcached_st
*memc_clone
;
374 memc_clone
= memcached_clone(NULL
, memc
);
375 test_true(memc_clone
);
378 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
379 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
380 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
381 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
384 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
385 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
386 test_true(memc_clone
->distribution
== memc
->distribution
);
387 { // Test all of the flags
388 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
389 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
390 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
391 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
392 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
393 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
394 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
395 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
396 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
397 test_true(memc_clone
->flags
.reply
== memc
->flags
.reply
);
398 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
399 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
400 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
402 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
403 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
404 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
405 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
406 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
407 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
408 test_true(memc_clone
->on_clone
== memc
->on_clone
);
409 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
410 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
411 test_true(memc_clone
->recv_size
== memc
->recv_size
);
412 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
413 test_true(memc_clone
->send_size
== memc
->send_size
);
414 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
415 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
416 test_true(memc_clone
->user_data
== memc
->user_data
);
418 memcached_free(memc_clone
);
421 /* Can we init from struct? */
423 memcached_st declared_clone
;
424 memcached_st
*memc_clone
;
425 memset(&declared_clone
, 0 , sizeof(memcached_st
));
426 memc_clone
= memcached_clone(&declared_clone
, NULL
);
427 test_true(memc_clone
);
428 memcached_free(memc_clone
);
431 /* Can we init from struct? */
433 memcached_st declared_clone
;
434 memcached_st
*memc_clone
;
435 memset(&declared_clone
, 0 , sizeof(memcached_st
));
436 memc_clone
= memcached_clone(&declared_clone
, memc
);
437 test_true(memc_clone
);
438 memcached_free(memc_clone
);
444 static test_return_t
userdata_test(memcached_st
*memc
)
447 test_false(memcached_set_user_data(memc
, foo
));
448 test_true(memcached_get_user_data(memc
) == foo
);
449 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
454 static test_return_t
connection_test(memcached_st
*memc
)
456 test_compare(MEMCACHED_SUCCESS
,
457 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
462 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
464 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
466 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
468 test_compare(36, int(MEMCACHED_BEHAVIOR_MAX
));
473 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
475 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
477 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
479 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
484 static test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
486 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
487 982370485U, 1263635348U, 4242906218U, 3829656100U,
488 1891735253U, 334139633U, 2257084983U, 3088286104U,
489 13199785U, 2542027183U, 1097051614U, 199566778U,
490 2748246961U, 2465192557U, 1664094137U, 2405439045U,
491 1842224848U, 692413798U, 3479807801U, 919913813U,
492 4269430871U, 610793021U, 527273862U, 1437122909U,
493 2300930706U, 2943759320U, 674306647U, 2400528935U,
494 54481931U, 4186304426U, 1741088401U, 2979625118U,
495 4159057246U, 3425930182U, 2593724503U, 1868899624U,
496 1769812374U, 2302537950U, 1110330676U, 3365377466U,
497 1336171666U, 3021258493U, 2334992265U, 3861994737U,
498 3582734124U, 3365377466U };
500 // You have updated the memcache_error messages but not updated docs/tests.
501 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
504 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
505 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
506 MEMCACHED_HASH_JENKINS
);
507 if (values
[rc
] != hash_val
)
509 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
510 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
512 test_compare(values
[rc
], hash_val
);
514 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
519 static test_return_t
set_test(memcached_st
*memc
)
521 memcached_return_t rc
= memcached_set(memc
,
522 test_literal_param("foo"),
523 test_literal_param("when we sanitize"),
524 time_t(0), (uint32_t)0);
525 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
530 static test_return_t
append_test(memcached_st
*memc
)
532 memcached_return_t rc
;
533 const char *in_value
= "we";
537 test_compare(MEMCACHED_SUCCESS
,
538 memcached_flush(memc
, 0));
540 test_compare(MEMCACHED_SUCCESS
,
542 test_literal_param(__func__
),
543 in_value
, strlen(in_value
),
544 time_t(0), uint32_t(0)));
546 test_compare(MEMCACHED_SUCCESS
,
547 memcached_append(memc
,
548 test_literal_param(__func__
),
549 " the", strlen(" the"),
550 time_t(0), uint32_t(0)));
552 test_compare(MEMCACHED_SUCCESS
,
553 memcached_append(memc
,
554 test_literal_param(__func__
),
555 " people", strlen(" people"),
556 time_t(0), uint32_t(0)));
558 char *out_value
= memcached_get(memc
,
559 test_literal_param(__func__
),
560 &value_length
, &flags
, &rc
);
561 test_memcmp(out_value
, "we the people", strlen("we the people"));
562 test_compare(strlen("we the people"), value_length
);
563 test_compare(MEMCACHED_SUCCESS
, rc
);
569 static test_return_t
append_binary_test(memcached_st
*memc
)
571 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
573 test_compare(MEMCACHED_SUCCESS
,
574 memcached_flush(memc
, 0));
576 test_compare(MEMCACHED_SUCCESS
,
578 test_literal_param(__func__
),
580 time_t(0), uint32_t(0)));
583 for (uint32_t x
= 0; store_list
[x
] ; x
++)
585 test_compare(MEMCACHED_SUCCESS
,
586 memcached_append(memc
,
587 test_literal_param(__func__
),
588 (char *)&store_list
[x
], sizeof(uint32_t),
589 time_t(0), uint32_t(0)));
595 memcached_return_t rc
;
596 uint32_t *value
= (uint32_t *)memcached_get(memc
,
597 test_literal_param(__func__
),
598 &value_length
, &flags
, &rc
);
599 test_compare(value_length
, sizeof(uint32_t) * count
);
600 test_compare(MEMCACHED_SUCCESS
, rc
);
602 for (uint32_t counter
= count
, *ptr
= value
; counter
; counter
--)
604 test_compare(*ptr
, store_list
[count
- counter
]);
612 static test_return_t
cas2_test(memcached_st
*memc
)
614 const char *keys
[]= {"fudge", "son", "food"};
615 size_t key_length
[]= {5, 3, 4};
616 const char *value
= "we the people";
617 size_t value_length
= strlen("we the people");
619 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
621 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
623 for (uint32_t x
= 0; x
< 3; x
++)
625 test_compare(MEMCACHED_SUCCESS
,
626 memcached_set(memc
, keys
[x
], key_length
[x
],
627 keys
[x
], key_length
[x
],
628 time_t(50), uint32_t(9)));
631 test_compare(MEMCACHED_SUCCESS
,
632 memcached_mget(memc
, keys
, key_length
, 3));
634 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
637 memcached_return_t rc
;
638 results
= memcached_fetch_result(memc
, results
, &rc
);
640 test_true(results
->item_cas
);
641 test_compare(MEMCACHED_SUCCESS
, rc
);
642 test_true(memcached_result_cas(results
));
644 test_memcmp(value
, "we the people", strlen("we the people"));
645 test_compare(strlen("we the people"), value_length
);
646 test_compare(MEMCACHED_SUCCESS
, rc
);
648 memcached_result_free(results
);
653 static test_return_t
cas_test(memcached_st
*memc
)
655 const char* keys
[2] = { __func__
, NULL
};
656 size_t keylengths
[2] = { strlen(__func__
), 0 };
658 memcached_result_st results_obj
;
660 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
662 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
664 test_compare(MEMCACHED_SUCCESS
,
666 test_literal_param(__func__
),
667 test_literal_param("we the people"),
668 (time_t)0, (uint32_t)0));
670 test_compare(MEMCACHED_SUCCESS
,
671 memcached_mget(memc
, keys
, keylengths
, 1));
673 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
676 memcached_return_t rc
;
677 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
679 test_compare(MEMCACHED_SUCCESS
, rc
);
680 test_true(memcached_result_cas(results
));
681 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
682 test_compare(test_literal_param_size("we the people"),
683 strlen(memcached_result_value(results
)));
685 uint64_t cas
= memcached_result_cas(results
);
688 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
689 test_true(rc
== MEMCACHED_END
);
690 test_true(results
== NULL
);
693 test_compare(MEMCACHED_SUCCESS
,
695 test_literal_param(__func__
),
696 test_literal_param("change the value"),
700 * The item will have a new cas value, so try to set it again with the old
701 * value. This should fail!
703 test_compare(MEMCACHED_DATA_EXISTS
,
705 test_literal_param(__func__
),
706 test_literal_param("change the value"),
709 memcached_result_free(&results_obj
);
714 static test_return_t
prepend_test(memcached_st
*memc
)
716 const char *key
= "fig";
717 const char *value
= "people";
719 test_compare(MEMCACHED_SUCCESS
,
720 memcached_flush(memc
, 0));
722 test_compare(MEMCACHED_SUCCESS
,
723 memcached_set(memc
, key
, strlen(key
),
724 value
, strlen(value
),
725 time_t(0), uint32_t(0)));
727 test_compare(MEMCACHED_SUCCESS
,
728 memcached_prepend(memc
, key
, strlen(key
),
729 "the ", strlen("the "),
730 time_t(0), uint32_t(0)));
732 test_compare(MEMCACHED_SUCCESS
,
733 memcached_prepend(memc
, key
, strlen(key
),
734 "we ", strlen("we "),
735 time_t(0), uint32_t(0)));
739 memcached_return_t rc
;
740 char *out_value
= memcached_get(memc
, key
, strlen(key
),
741 &value_length
, &flags
, &rc
);
742 test_memcmp(out_value
, "we the people", strlen("we the people"));
743 test_compare(strlen("we the people"), value_length
);
744 test_compare(MEMCACHED_SUCCESS
, rc
);
751 Set the value, then quit to make sure it is flushed.
752 Come back in and test that add fails.
754 static test_return_t
add_test(memcached_st
*memc
)
756 test_compare_hint(return_value_based_on_buffering(memc
),
758 test_literal_param(__func__
),
759 test_literal_param("when we sanitize"),
760 time_t(0), uint32_t(0)),
761 memcached_last_error_message(memc
));
763 memcached_quit(memc
);
765 test_compare_hint(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
767 test_literal_param(__func__
),
768 test_literal_param("try something else"),
769 time_t(0), uint32_t(0)),
770 memcached_last_error_message(memc
));
776 ** There was a problem of leaking filedescriptors in the initial release
777 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
778 ** systems it seems that the kernel is slow on reclaiming the resources
779 ** because the connects starts to time out (the test doesn't do much
780 ** anyway, so just loop 10 iterations)
782 static test_return_t
add_wrapper(memcached_st
*memc
)
784 unsigned int max
= 10000;
792 for (uint32_t x
= 0; x
< max
; x
++)
798 static test_return_t
replace_test(memcached_st
*memc
)
800 test_compare(return_value_based_on_buffering(memc
),
802 test_literal_param(__func__
),
803 test_literal_param("when we sanitize"),
804 time_t(0), uint32_t(0)));
806 test_compare(MEMCACHED_SUCCESS
,
807 memcached_replace(memc
,
808 test_literal_param(__func__
),
809 test_literal_param("first we insert some data"),
810 time_t(0), uint32_t(0)));
815 static test_return_t
delete_test(memcached_st
*memc
)
817 test_compare(return_value_based_on_buffering(memc
),
819 test_literal_param(__func__
),
820 test_literal_param("when we sanitize"),
821 time_t(0), uint32_t(0)));
823 test_compare_hint(return_value_based_on_buffering(memc
),
824 memcached_delete(memc
,
825 test_literal_param(__func__
),
827 memcached_last_error_message(memc
));
832 static test_return_t
flush_test(memcached_st
*memc
)
834 uint64_t query_id
= memcached_query_id(memc
);
835 test_compare(MEMCACHED_SUCCESS
,
836 memcached_flush(memc
, 0));
837 test_compare(query_id
+1, memcached_query_id(memc
));
842 static memcached_return_t
server_function(const memcached_st
*,
843 const memcached_server_st
*,
847 return MEMCACHED_SUCCESS
;
850 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
853 strncpy(context
, "foo bad", sizeof(context
));
854 memcached_server_fn callbacks
[1];
856 callbacks
[0]= server_function
;
857 memcached_server_cursor(memc
, callbacks
, context
, 1);
861 static test_return_t
bad_key_test(memcached_st
*memc
)
863 memcached_return_t rc
;
864 const char *key
= "foo bad";
867 uint64_t query_id
= memcached_query_id(memc
);
869 // Just skip if we are in binary mode.
870 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
872 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
874 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
875 test_true(memc_clone
);
877 query_id
= memcached_query_id(memc_clone
);
878 test_compare(MEMCACHED_SUCCESS
,
879 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
880 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
882 /* All keys are valid in the binary protocol (except for length) */
883 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
885 uint64_t before_query_id
= memcached_query_id(memc_clone
);
887 size_t string_length
;
888 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
889 &string_length
, &flags
, &rc
);
890 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
891 test_zero(string_length
);
894 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
896 query_id
= memcached_query_id(memc_clone
);
897 test_compare(MEMCACHED_SUCCESS
,
898 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
899 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
901 size_t string_length
;
902 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
903 &string_length
, &flags
, &rc
);
904 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
905 test_zero(string_length
);
909 /* Test multi key for bad keys */
910 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
911 size_t key_lengths
[] = { 7, 7, 7 };
912 query_id
= memcached_query_id(memc_clone
);
913 test_compare(MEMCACHED_SUCCESS
,
914 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
915 test_compare(query_id
, memcached_query_id(memc_clone
));
917 query_id
= memcached_query_id(memc_clone
);
918 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
919 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
920 test_compare(query_id
+1, memcached_query_id(memc_clone
));
922 query_id
= memcached_query_id(memc_clone
);
923 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
924 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
925 test_compare(query_id
+1, memcached_query_id(memc_clone
));
927 /* The following test should be moved to the end of this function when the
928 memcached server is updated to allow max size length of the keys in the
931 test_compare(MEMCACHED_SUCCESS
,
932 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
934 std::vector
<char> longkey
;
936 std::vector
<char>::iterator it
= longkey
.begin();
937 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
940 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
942 size_t string_length
;
944 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
945 test_compare(MEMCACHED_NOTFOUND
, rc
);
946 test_zero(string_length
);
948 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
949 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
950 test_zero(string_length
);
954 /* Make sure zero length keys are marked as bad */
956 test_compare(MEMCACHED_SUCCESS
,
957 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
958 size_t string_length
;
959 char *string
= memcached_get(memc_clone
, key
, 0,
960 &string_length
, &flags
, &rc
);
961 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
962 test_zero(string_length
);
966 memcached_free(memc_clone
);
971 #define READ_THROUGH_VALUE "set for me"
972 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
975 memcached_result_st
*result
)
977 (void)memc
;(void)key
;(void)key_length
;
978 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
981 #ifndef __INTEL_COMPILER
982 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
985 static test_return_t
read_through(memcached_st
*memc
)
987 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
989 size_t string_length
;
991 memcached_return_t rc
;
992 char *string
= memcached_get(memc
,
993 test_literal_param(__func__
),
994 &string_length
, &flags
, &rc
);
996 test_compare(MEMCACHED_NOTFOUND
, rc
);
997 test_false(string_length
);
1000 test_compare(MEMCACHED_SUCCESS
,
1001 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1003 string
= memcached_get(memc
,
1004 test_literal_param(__func__
),
1005 &string_length
, &flags
, &rc
);
1007 test_compare(MEMCACHED_SUCCESS
, rc
);
1008 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1009 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1010 test_strcmp(READ_THROUGH_VALUE
, string
);
1013 string
= memcached_get(memc
,
1014 test_literal_param(__func__
),
1015 &string_length
, &flags
, &rc
);
1017 test_compare(MEMCACHED_SUCCESS
, rc
);
1019 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1020 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1021 test_strcmp(READ_THROUGH_VALUE
, string
);
1024 return TEST_SUCCESS
;
1027 static test_return_t
get_test(memcached_st
*memc
)
1029 memcached_return_t rc
;
1031 size_t string_length
;
1034 uint64_t query_id
= memcached_query_id(memc
);
1035 rc
= memcached_delete(memc
,
1036 test_literal_param(__func__
),
1038 test_true_got(rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_NOTFOUND
, memcached_last_error_message(memc
));
1039 test_compare(query_id
+1, memcached_query_id(memc
));
1041 string
= memcached_get(memc
,
1042 test_literal_param(__func__
),
1043 &string_length
, &flags
, &rc
);
1045 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1046 test_false(string_length
);
1049 return TEST_SUCCESS
;
1052 static test_return_t
get_test2(memcached_st
*memc
)
1054 const char *value
= "when we sanitize";
1056 uint64_t query_id
= memcached_query_id(memc
);
1057 test_compare(return_value_based_on_buffering(memc
),
1059 test_literal_param(__func__
),
1060 value
, strlen(value
),
1061 time_t(0), uint32_t(0)));
1062 test_compare(query_id
+1, memcached_query_id(memc
));
1064 query_id
= memcached_query_id(memc
);
1065 test_true(query_id
);
1068 size_t string_length
;
1069 memcached_return_t rc
;
1070 char *string
= memcached_get(memc
,
1071 test_literal_param(__func__
),
1072 &string_length
, &flags
, &rc
);
1073 test_compare(query_id
+1, memcached_query_id(memc
));
1075 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1076 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1078 test_compare(strlen(value
), string_length
);
1079 test_memcmp(string
, value
, string_length
);
1083 return TEST_SUCCESS
;
1086 static test_return_t
set_test2(memcached_st
*memc
)
1088 for (uint32_t x
= 0; x
< 10; x
++)
1090 test_compare(return_value_based_on_buffering(memc
),
1092 test_literal_param("foo"),
1093 test_literal_param("train in the brain"),
1094 time_t(0), uint32_t(0)));
1097 return TEST_SUCCESS
;
1100 static test_return_t
set_test3(memcached_st
*memc
)
1102 size_t value_length
= 8191;
1104 std::vector
<char> value
;
1105 value
.reserve(value_length
);
1106 for (uint32_t x
= 0; x
< value_length
; x
++)
1108 value
.push_back(char(x
% 127));
1111 /* The dump test relies on there being at least 32 items in memcached */
1112 for (uint32_t x
= 0; x
< 32; x
++)
1116 snprintf(key
, sizeof(key
), "foo%u", x
);
1118 uint64_t query_id
= memcached_query_id(memc
);
1119 test_compare_hint(return_value_based_on_buffering(memc
),
1120 memcached_set(memc
, key
, strlen(key
),
1121 &value
[0], value
.size(),
1122 time_t(0), uint32_t(0)),
1123 memcached_last_error_message(memc
));
1124 test_compare(query_id
+1, memcached_query_id(memc
));
1127 return TEST_SUCCESS
;
1130 static test_return_t
get_test3(memcached_st
*memc
)
1132 size_t value_length
= 8191;
1134 std::vector
<char> value
;
1135 value
.reserve(value_length
);
1136 for (uint32_t x
= 0; x
< value_length
; x
++)
1138 value
.push_back(char(x
% 127));
1141 test_compare_hint(return_value_based_on_buffering(memc
),
1143 test_literal_param(__func__
),
1144 &value
[0], value
.size(),
1145 time_t(0), uint32_t(0)),
1146 memcached_last_error_message(memc
));
1148 size_t string_length
;
1150 memcached_return_t rc
;
1151 char *string
= memcached_get(memc
,
1152 test_literal_param(__func__
),
1153 &string_length
, &flags
, &rc
);
1155 test_compare(MEMCACHED_SUCCESS
, rc
);
1157 test_compare(value
.size(), string_length
);
1158 test_memcmp(string
, &value
[0], string_length
);
1162 return TEST_SUCCESS
;
1165 static test_return_t
get_test4(memcached_st
*memc
)
1167 size_t value_length
= 8191;
1169 std::vector
<char> value
;
1170 value
.reserve(value_length
);
1171 for (uint32_t x
= 0; x
< value_length
; x
++)
1173 value
.push_back(char(x
% 127));
1176 test_compare_hint(return_value_based_on_buffering(memc
),
1178 test_literal_param(__func__
),
1179 &value
[0], value
.size(),
1180 time_t(0), uint32_t(0)),
1181 memcached_last_error_message(memc
));
1183 for (uint32_t x
= 0; x
< 10; x
++)
1186 size_t string_length
;
1187 memcached_return_t rc
;
1188 char *string
= memcached_get(memc
,
1189 test_literal_param(__func__
),
1190 &string_length
, &flags
, &rc
);
1192 test_compare(MEMCACHED_SUCCESS
, rc
);
1194 test_compare(value
.size(), string_length
);
1195 test_memcmp(string
, &value
[0], string_length
);
1199 return TEST_SUCCESS
;
1203 * This test verifies that memcached_read_one_response doesn't try to
1204 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1205 * responses before you execute a storage command.
1207 static test_return_t
get_test5(memcached_st
*memc
)
1210 ** Request the same key twice, to ensure that we hash to the same server
1211 ** (so that we have multiple response values queued up) ;-)
1213 const char *keys
[]= { "key", "key" };
1214 size_t lengths
[]= { 3, 3 };
1218 test_compare_hint(return_value_based_on_buffering(memc
),
1219 memcached_set(memc
, keys
[0], lengths
[0],
1220 keys
[0], lengths
[0],
1221 time_t(0), uint32_t(0)),
1222 memcached_last_error_message(memc
));
1223 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1225 memcached_result_st results_obj
;
1226 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1229 memcached_return_t rc
;
1230 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1233 memcached_result_free(&results_obj
);
1235 /* Don't read out the second result, but issue a set instead.. */
1236 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1238 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1239 &rlen
, &flags
, &rc
);
1241 test_compare(MEMCACHED_NOTFOUND
, rc
);
1242 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1244 test_compare(MEMCACHED_SUCCESS
, rc
);
1247 return TEST_SUCCESS
;
1250 static test_return_t
mget_end(memcached_st
*memc
)
1252 const char *keys
[]= { "foo", "foo2" };
1253 size_t lengths
[]= { 3, 4 };
1254 const char *values
[]= { "fjord", "41" };
1257 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1259 test_compare(MEMCACHED_SUCCESS
,
1261 keys
[x
], lengths
[x
],
1262 values
[x
], strlen(values
[x
]),
1263 time_t(0), uint32_t(0)));
1267 size_t string_length
;
1270 // retrieve both via mget
1271 test_compare(MEMCACHED_SUCCESS
,
1272 memcached_mget(memc
,
1274 test_array_length(keys
)));
1276 char key
[MEMCACHED_MAX_KEY
];
1278 memcached_return_t rc
;
1280 // this should get both
1281 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1283 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1285 test_compare(MEMCACHED_SUCCESS
, rc
);
1287 if (key_length
== 4)
1292 test_compare(string_length
, strlen(values
[val
]));
1293 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1297 // this should indicate end
1298 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1299 test_compare(MEMCACHED_END
, rc
);
1303 test_compare(MEMCACHED_SUCCESS
,
1304 memcached_mget(memc
, keys
, lengths
, 1));
1306 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1307 test_compare(key_length
, lengths
[0]);
1308 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1309 test_compare(string_length
, strlen(values
[0]));
1310 test_true(strncmp(values
[0], string
, string_length
) == 0);
1311 test_compare(MEMCACHED_SUCCESS
, rc
);
1314 // this should indicate end
1315 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1316 test_compare(MEMCACHED_END
, rc
);
1319 return TEST_SUCCESS
;
1322 /* Do not copy the style of this code, I just access hosts to testthis function */
1323 static test_return_t
stats_servername_test(memcached_st
*memc
)
1325 memcached_stat_st memc_stat
;
1326 memcached_server_instance_st instance
=
1327 memcached_server_instance_by_position(memc
, 0);
1329 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1331 return TEST_SKIPPED
;
1334 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1335 memcached_server_name(instance
),
1336 memcached_server_port(instance
)));
1338 return TEST_SUCCESS
;
1341 static test_return_t
increment_test(memcached_st
*memc
)
1343 uint64_t new_number
;
1345 test_compare(MEMCACHED_SUCCESS
,
1347 test_literal_param("number"),
1348 test_literal_param("0"),
1349 (time_t)0, (uint32_t)0));
1351 test_compare(MEMCACHED_SUCCESS
,
1352 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1353 test_compare(uint64_t(1), new_number
);
1355 test_compare(MEMCACHED_SUCCESS
,
1356 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1357 test_compare(uint64_t(2), new_number
);
1359 return TEST_SUCCESS
;
1362 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1364 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1366 uint64_t new_number
;
1367 uint64_t initial
= 0;
1369 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1371 test_compare(MEMCACHED_SUCCESS
,
1372 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1373 test_compare(new_number
, initial
);
1375 test_compare(MEMCACHED_SUCCESS
,
1376 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1377 test_compare(new_number
, (initial
+1));
1379 return TEST_SUCCESS
;
1382 static test_return_t
decrement_test(memcached_st
*memc
)
1384 test_compare(return_value_based_on_buffering(memc
),
1386 test_literal_param(__func__
),
1387 test_literal_param("3"),
1388 time_t(0), uint32_t(0)));
1389 // Make sure we flush the value we just set
1390 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1392 uint64_t new_number
;
1393 test_compare(MEMCACHED_SUCCESS
,
1394 memcached_decrement(memc
,
1395 test_literal_param(__func__
),
1397 test_compare(uint64_t(2), new_number
);
1399 test_compare(MEMCACHED_SUCCESS
,
1400 memcached_decrement(memc
,
1401 test_literal_param(__func__
),
1403 test_compare(uint64_t(1), new_number
);
1405 return TEST_SUCCESS
;
1408 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1410 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1412 uint64_t initial
= 3;
1414 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1416 uint64_t new_number
;
1417 test_compare(MEMCACHED_SUCCESS
,
1418 memcached_decrement_with_initial(memc
,
1419 test_literal_param(__func__
),
1422 test_compare(new_number
, initial
);
1424 test_compare(MEMCACHED_SUCCESS
,
1425 memcached_decrement_with_initial(memc
,
1426 test_literal_param(__func__
),
1429 test_compare(new_number
, (initial
- 1));
1431 return TEST_SUCCESS
;
1434 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1436 const char *master_key
= "foo";
1437 const char *key
= "number";
1438 const char *value
= "0";
1440 test_compare(return_value_based_on_buffering(memc
),
1441 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1443 value
, strlen(value
),
1444 time_t(0), uint32_t(0)));
1446 // Make sure we flush the value we just set
1447 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1449 uint64_t new_number
;
1450 test_compare(MEMCACHED_SUCCESS
,
1451 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1452 key
, strlen(key
), 1, &new_number
));
1453 test_compare(uint64_t(1), new_number
);
1455 test_compare(MEMCACHED_SUCCESS
,
1456 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1457 key
, strlen(key
), 1, &new_number
));
1458 test_compare(uint64_t(2), new_number
);
1460 return TEST_SUCCESS
;
1463 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1465 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1467 uint64_t new_number
;
1468 const char *master_key
= "foo";
1469 const char *key
= "number";
1470 uint64_t initial
= 0;
1472 test_compare(MEMCACHED_SUCCESS
,
1473 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1475 1, initial
, 0, &new_number
));
1476 test_compare(new_number
, initial
);
1478 test_compare(MEMCACHED_SUCCESS
,
1479 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1481 1, initial
, 0, &new_number
));
1482 test_compare(new_number
, (initial
+1));
1484 return TEST_SUCCESS
;
1487 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1489 uint64_t new_number
;
1490 const char *value
= "3";
1492 test_compare(return_value_based_on_buffering(memc
),
1493 memcached_set_by_key(memc
,
1494 test_literal_param("foo"),
1495 test_literal_param("number"),
1496 value
, strlen(value
),
1497 (time_t)0, (uint32_t)0));
1499 test_compare(MEMCACHED_SUCCESS
,
1500 memcached_decrement_by_key(memc
,
1501 test_literal_param("foo"),
1502 test_literal_param("number"),
1504 test_compare(uint64_t(2), new_number
);
1506 test_compare(MEMCACHED_SUCCESS
,
1507 memcached_decrement_by_key(memc
,
1508 test_literal_param("foo"),
1509 test_literal_param("number"),
1511 test_compare(uint64_t(1), new_number
);
1513 return TEST_SUCCESS
;
1516 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1518 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1520 uint64_t new_number
;
1521 uint64_t initial
= 3;
1523 test_compare(MEMCACHED_SUCCESS
,
1524 memcached_decrement_with_initial_by_key(memc
,
1525 test_literal_param("foo"),
1526 test_literal_param("number"),
1527 1, initial
, 0, &new_number
));
1528 test_compare(new_number
, initial
);
1530 test_compare(MEMCACHED_SUCCESS
,
1531 memcached_decrement_with_initial_by_key(memc
,
1532 test_literal_param("foo"),
1533 test_literal_param("number"),
1534 1, initial
, 0, &new_number
));
1535 test_compare(new_number
, (initial
- 1));
1537 return TEST_SUCCESS
;
1539 static test_return_t
binary_increment_with_prefix_test(memcached_st
*orig_memc
)
1541 memcached_st
*memc
= memcached_clone(NULL
, orig_memc
);
1543 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1545 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1547 test_compare(return_value_based_on_buffering(memc
),
1549 test_literal_param("number"),
1550 test_literal_param("0"),
1551 (time_t)0, (uint32_t)0));
1553 uint64_t new_number
;
1554 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1555 test_literal_param("number"),
1557 test_compare(uint64_t(1), new_number
);
1559 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1560 test_literal_param("number"),
1562 test_compare(uint64_t(2), new_number
);
1563 memcached_free(memc
);
1565 return TEST_SUCCESS
;
1568 static test_return_t
quit_test(memcached_st
*memc
)
1570 const char *value
= "sanford and sun";
1572 test_compare(return_value_based_on_buffering(memc
),
1574 test_literal_param(__func__
),
1575 value
, strlen(value
),
1576 (time_t)10, (uint32_t)3));
1577 memcached_quit(memc
);
1579 test_compare(return_value_based_on_buffering(memc
),
1581 test_literal_param(__func__
),
1582 value
, strlen(value
),
1583 (time_t)50, (uint32_t)9));
1585 return TEST_SUCCESS
;
1588 static test_return_t
mget_result_test(memcached_st
*memc
)
1590 const char *keys
[]= {"fudge", "son", "food"};
1591 size_t key_length
[]= {5, 3, 4};
1593 memcached_result_st results_obj
;
1594 memcached_result_st
*results
;
1596 results
= memcached_result_create(memc
, &results_obj
);
1598 test_true(&results_obj
== results
);
1600 /* We need to empty the server before continueing test */
1601 test_compare(MEMCACHED_SUCCESS
,
1602 memcached_flush(memc
, 0));
1604 test_compare(MEMCACHED_SUCCESS
,
1605 memcached_mget(memc
, keys
, key_length
, 3));
1607 memcached_return_t rc
;
1608 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1613 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1614 test_false(results
);
1615 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1617 for (uint32_t x
= 0; x
< 3; x
++)
1619 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1620 keys
[x
], key_length
[x
],
1621 (time_t)50, (uint32_t)9);
1622 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1625 test_compare(MEMCACHED_SUCCESS
,
1626 memcached_mget(memc
, keys
, key_length
, 3));
1628 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1631 test_true(&results_obj
== results
);
1632 test_compare(MEMCACHED_SUCCESS
, rc
);
1633 test_memcmp(memcached_result_key_value(results
),
1634 memcached_result_value(results
),
1635 memcached_result_length(results
));
1636 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1639 memcached_result_free(&results_obj
);
1641 return TEST_SUCCESS
;
1644 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1646 const char *keys
[]= {"fudge", "son", "food"};
1647 size_t key_length
[]= {5, 3, 4};
1649 memcached_result_st
*results
;
1651 /* We need to empty the server before continueing test */
1652 test_compare(MEMCACHED_SUCCESS
,
1653 memcached_flush(memc
, 0));
1655 test_compare(MEMCACHED_SUCCESS
,
1656 memcached_mget(memc
, keys
, key_length
, 3));
1658 memcached_return_t rc
;
1659 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1663 test_false(results
);
1664 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1666 for (uint32_t x
= 0; x
< 3; x
++)
1668 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1669 keys
[x
], key_length
[x
],
1670 (time_t)50, (uint32_t)9);
1671 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1674 test_compare(MEMCACHED_SUCCESS
,
1675 memcached_mget(memc
, keys
, key_length
, 3));
1678 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1681 test_compare(MEMCACHED_SUCCESS
, rc
);
1682 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1683 test_memcmp(memcached_result_key_value(results
),
1684 memcached_result_value(results
),
1685 memcached_result_length(results
));
1686 memcached_result_free(results
);
1690 return TEST_SUCCESS
;
1693 /* Count the results */
1694 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1696 size_t *counter
= (size_t *)context
;
1698 *counter
= *counter
+ 1;
1700 return MEMCACHED_SUCCESS
;
1703 static test_return_t
mget_result_function(memcached_st
*memc
)
1705 const char *keys
[]= {"fudge", "son", "food"};
1706 size_t key_length
[]= {5, 3, 4};
1708 memcached_execute_fn callbacks
[1];
1710 for (uint32_t x
= 0; x
< 3; x
++)
1712 test_compare(return_value_based_on_buffering(memc
),
1713 memcached_set(memc
, keys
[x
], key_length
[x
],
1714 keys
[x
], key_length
[x
],
1715 time_t(50), uint32_t(9)));
1717 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1718 memcached_quit(memc
);
1720 test_compare(MEMCACHED_SUCCESS
,
1721 memcached_mget(memc
, keys
, key_length
, 3));
1723 callbacks
[0]= &callback_counter
;
1726 test_compare(MEMCACHED_SUCCESS
,
1727 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1729 test_compare(size_t(3), counter
);
1731 return TEST_SUCCESS
;
1734 static test_return_t
mget_test(memcached_st
*memc
)
1736 const char *keys
[]= {"fudge", "son", "food"};
1737 size_t key_length
[]= {5, 3, 4};
1739 char return_key
[MEMCACHED_MAX_KEY
];
1740 size_t return_key_length
;
1742 size_t return_value_length
;
1744 test_compare(MEMCACHED_SUCCESS
,
1745 memcached_mget(memc
, keys
, key_length
, 3));
1748 memcached_return_t rc
;
1749 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1750 &return_value_length
, &flags
, &rc
)))
1752 test_true(return_value
);
1754 test_false(return_value
);
1755 test_zero(return_value_length
);
1756 test_compare(MEMCACHED_NOTFOUND
, rc
);
1758 for (uint32_t x
= 0; x
< 3; x
++)
1760 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1761 keys
[x
], key_length
[x
],
1762 (time_t)50, (uint32_t)9);
1763 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1765 test_compare(MEMCACHED_SUCCESS
,
1766 memcached_mget(memc
, keys
, key_length
, 3));
1769 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1770 &return_value_length
, &flags
, &rc
)))
1772 test_true(return_value
);
1773 test_compare(MEMCACHED_SUCCESS
, rc
);
1774 if (not memc
->_namespace
)
1776 test_compare(return_key_length
, return_value_length
);
1777 test_memcmp(return_value
, return_key
, return_value_length
);
1783 return TEST_SUCCESS
;
1786 static test_return_t
mget_execute(memcached_st
*original_memc
)
1788 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1790 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1793 size_t max_keys
= 20480;
1796 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1797 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1799 /* First add all of the items.. */
1800 char blob
[1024] = {0};
1802 for (size_t x
= 0; x
< max_keys
; ++x
)
1806 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1808 test_true(keys
[x
] != NULL
);
1809 uint64_t query_id
= memcached_query_id(memc
);
1810 memcached_return_t rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1811 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1812 test_compare(query_id
+1, memcached_query_id(memc
));
1815 /* Try to get all of them with a large multiget */
1817 memcached_execute_fn callbacks
[]= { &callback_counter
};
1818 test_compare(MEMCACHED_SUCCESS
,
1819 memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1820 max_keys
, callbacks
, &counter
, 1));
1823 uint64_t query_id
= memcached_query_id(memc
);
1824 test_compare(MEMCACHED_SUCCESS
,
1825 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1826 test_compare(query_id
, memcached_query_id(memc
));
1828 /* Verify that we got all of the items */
1829 test_true(counter
== max_keys
);
1832 /* Release all allocated resources */
1833 for (size_t x
= 0; x
< max_keys
; ++x
)
1840 memcached_free(memc
);
1842 return TEST_SUCCESS
;
1845 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1847 static test_return_t
key_setup(memcached_st
*memc
)
1849 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1851 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1853 return TEST_SUCCESS
;
1856 static test_return_t
key_teardown(memcached_st
*memc
)
1859 pairs_free(global_pairs
);
1861 return TEST_SUCCESS
;
1864 static test_return_t
block_add_regression(memcached_st
*memc
)
1866 /* First add all of the items.. */
1867 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1869 char blob
[1024] = {0};
1871 memcached_return_t rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1872 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
, memcached_strerror(NULL
, rc
));
1875 return TEST_SUCCESS
;
1878 static test_return_t
binary_add_regression(memcached_st
*memc
)
1880 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1881 test_return_t rc
= block_add_regression(memc
);
1886 static test_return_t
get_stats_keys(memcached_st
*memc
)
1890 memcached_stat_st memc_stat
;
1891 memcached_return_t rc
;
1893 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1894 test_compare(MEMCACHED_SUCCESS
, rc
);
1895 for (ptr
= stat_list
; *ptr
; ptr
++)
1900 return TEST_SUCCESS
;
1903 static test_return_t
version_string_test(memcached_st
*)
1905 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1907 return TEST_SUCCESS
;
1910 static test_return_t
get_stats(memcached_st
*memc
)
1912 memcached_return_t rc
;
1914 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1915 test_compare(MEMCACHED_SUCCESS
, rc
);
1916 test_true(memc_stat
);
1918 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1920 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1921 test_compare(MEMCACHED_SUCCESS
, rc
);
1922 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1927 memcached_stat_free(NULL
, memc_stat
);
1929 return TEST_SUCCESS
;
1932 static test_return_t
add_host_test(memcached_st
*memc
)
1934 char servername
[]= "0.example.com";
1936 memcached_return_t rc
;
1937 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1938 test_compare(1U, memcached_server_list_count(servers
));
1940 for (unsigned int x
= 2; x
< 20; x
++)
1942 char buffer
[SMALL_STRING_LEN
];
1944 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1945 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1947 test_compare(MEMCACHED_SUCCESS
, rc
);
1948 test_compare(x
, memcached_server_list_count(servers
));
1951 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1952 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1954 memcached_server_list_free(servers
);
1956 return TEST_SUCCESS
;
1959 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1961 memcached_return_t rc
;
1963 const char *key
= "not_found";
1964 size_t key_length
= test_literal_param_size("not_found");
1966 test_compare(MEMCACHED_SUCCESS
,
1967 memcached_mget(memc
, &key
, &key_length
, 1));
1969 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1971 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1973 memcached_result_free(result
);
1975 return TEST_SUCCESS
;
1978 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1980 return MEMCACHED_SUCCESS
;
1983 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1985 return MEMCACHED_SUCCESS
;
1988 static test_return_t
callback_test(memcached_st
*memc
)
1990 /* Test User Data */
1994 memcached_return_t rc
;
1996 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1997 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1998 test_true(*test_ptr
== x
);
2001 /* Test Clone Callback */
2003 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2004 void *clone_cb_ptr
= *(void **)&clone_cb
;
2005 void *temp_function
= NULL
;
2007 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
2008 memcached_return_t rc
;
2009 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2010 test_true(temp_function
== clone_cb_ptr
);
2011 test_compare(MEMCACHED_SUCCESS
, rc
);
2014 /* Test Cleanup Callback */
2016 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2017 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2018 void *temp_function
= NULL
;
2019 memcached_return_t rc
;
2021 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2022 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2023 test_true(temp_function
== cleanup_cb_ptr
);
2026 return TEST_SUCCESS
;
2029 /* We don't test the behavior itself, we test the switches */
2030 static test_return_t
behavior_test(memcached_st
*memc
)
2032 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2033 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2035 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2036 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2038 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2039 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2041 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2042 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2044 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2045 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2047 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2048 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2050 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2051 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2053 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2055 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2057 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2058 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2059 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2061 return TEST_SUCCESS
;
2064 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2066 test_compare(MEMCACHED_DEPRECATED
,
2067 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2069 // Platform dependent
2071 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2075 return TEST_SUCCESS
;
2079 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2081 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2082 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2084 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2086 if (memcached_success(rc
))
2095 return TEST_SUCCESS
;
2099 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2101 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2102 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2104 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2106 if (memcached_success(rc
))
2115 return TEST_SUCCESS
;
2118 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, memcached_return_t
& rc
)
2122 memcached_result_st
* result
;
2123 while ((result
= memcached_fetch_result(memc
, NULL
, &rc
)))
2125 test_compare(MEMCACHED_SUCCESS
, rc
);
2129 return TEST_SUCCESS
;
2132 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
)
2134 memcached_return_t rc
;
2135 return fetch_all_results(memc
, keys_returned
, rc
);
2138 /* Test case provided by Cal Haldenbrand */
2139 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2140 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2141 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2143 /* We just keep looking at the same values over and over */
2146 test_compare(MEMCACHED_SUCCESS
,
2147 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2148 test_compare(MEMCACHED_SUCCESS
,
2149 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2153 unsigned long long total
= 0;
2154 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2156 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2157 char randomstuff
[6 * 1024];
2158 memset(randomstuff
, 0, 6 * 1024);
2159 test_true(size
< 6 * 1024); /* Being safe here */
2161 for (uint32_t j
= 0 ; j
< size
;j
++)
2163 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2167 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2168 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2169 test_compare(MEMCACHED_SUCCESS
,
2170 memcached_set(memc
, key
, key_length
,
2171 randomstuff
, strlen(randomstuff
),
2172 time_t(0), HALDENBRAND_FLAG_KEY
));
2174 test_true(total
> HALDENBRAND_KEY_COUNT
);
2176 return TEST_SUCCESS
;
2179 /* Test case provided by Cal Haldenbrand */
2180 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2182 test_compare(MEMCACHED_SUCCESS
,
2183 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2185 test_compare(MEMCACHED_SUCCESS
,
2186 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2189 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576));
2190 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576));
2191 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2192 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2194 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2197 size_t total_value_length
= 0;
2198 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2203 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2204 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2206 memcached_return_t rc
;
2207 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2208 if (memcached_failed(rc
))
2210 if (rc
== MEMCACHED_NOTFOUND
)
2221 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2224 total_value_length
+= val_len
;
2229 return TEST_SUCCESS
;
2232 /* Do a large mget() over all the keys we think exist */
2233 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2235 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2236 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2239 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576);
2240 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576);
2241 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2242 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2245 std::vector
<size_t> key_lengths
;
2246 key_lengths
.resize(HALDENBRAND_KEY_COUNT
);
2247 std::vector
<char *> keys
;
2248 keys
.resize(key_lengths
.size());
2249 for (uint32_t x
= 0; x
< key_lengths
.size(); x
++)
2251 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2252 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2253 test_true(key_length
> 0 and key_length
< MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1);
2254 keys
[x
]= strdup(key
);
2255 key_lengths
[x
]= key_length
;
2258 test_compare(MEMCACHED_SUCCESS
,
2259 memcached_mget(memc
, &keys
[0], &key_lengths
[0], key_lengths
.size()));
2261 unsigned int keys_returned
;
2262 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
));
2263 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2265 for (std::vector
<char *>::iterator iter
= keys
.begin();
2272 return TEST_SUCCESS
;
2275 /* Make sure we behave properly if server list has no values */
2276 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2278 const char *keys
[]= {"fudge", "son", "food"};
2279 size_t key_length
[]= {5, 3, 4};
2281 /* Here we free everything before running a bunch of mget tests */
2282 memcached_servers_reset(memc
);
2285 /* We need to empty the server before continueing test */
2286 test_compare(MEMCACHED_NO_SERVERS
,
2287 memcached_flush(memc
, 0));
2289 test_compare(MEMCACHED_NO_SERVERS
,
2290 memcached_mget(memc
, keys
, key_length
, 3));
2293 unsigned int keys_returned
;
2294 memcached_return_t rc
;
2295 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2296 test_compare(MEMCACHED_NOTFOUND
, rc
);
2297 test_zero(keys_returned
);
2300 for (uint32_t x
= 0; x
< 3; x
++)
2302 test_compare(MEMCACHED_NO_SERVERS
,
2303 memcached_set(memc
, keys
[x
], key_length
[x
],
2304 keys
[x
], key_length
[x
],
2305 (time_t)50, (uint32_t)9));
2308 test_compare(MEMCACHED_NO_SERVERS
,
2309 memcached_mget(memc
, keys
, key_length
, 3));
2313 char return_key
[MEMCACHED_MAX_KEY
];
2314 memcached_return_t rc
;
2315 size_t return_key_length
;
2316 size_t return_value_length
;
2319 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2320 &return_value_length
, &flags
, &rc
)))
2322 test_true(return_value
);
2323 test_compare(MEMCACHED_SUCCESS
, rc
);
2324 test_true(return_key_length
== return_value_length
);
2325 test_memcmp(return_value
, return_key
, return_value_length
);
2331 return TEST_SUCCESS
;
2334 #define VALUE_SIZE_BUG5 1048064
2335 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2337 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2338 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2340 size_t value_length
;
2342 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2344 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2346 insert_data
[x
]= (signed char)rand();
2349 test_compare(MEMCACHED_SUCCESS
,
2350 memcached_flush(memc
, 0));
2352 memcached_return_t rc
;
2353 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2354 test_compare(MEMCACHED_SUCCESS
,
2355 memcached_mget(memc
, keys
, key_length
, 4));
2358 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2359 test_compare(MEMCACHED_NOTFOUND
, rc
);
2362 for (uint32_t x
= 0; x
< 4; x
++)
2364 test_compare(MEMCACHED_SUCCESS
,
2365 memcached_set(memc
, keys
[x
], key_length
[x
],
2366 insert_data
, VALUE_SIZE_BUG5
,
2367 (time_t)0, (uint32_t)0));
2370 for (uint32_t x
= 0; x
< 10; x
++)
2372 value
= memcached_get(memc
, keys
[0], key_length
[0],
2373 &value_length
, &flags
, &rc
);
2374 test_compare(rc
, MEMCACHED_SUCCESS
);
2378 test_compare(MEMCACHED_SUCCESS
,
2379 memcached_mget(memc
, keys
, key_length
, 4));
2381 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2382 test_compare(4U, count
);
2384 delete [] insert_data
;
2386 return TEST_SUCCESS
;
2389 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2391 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2392 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2393 char return_key
[MEMCACHED_MAX_KEY
];
2394 size_t return_key_length
;
2396 size_t value_length
;
2398 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2400 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2402 insert_data
[x
]= (signed char)rand();
2405 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2407 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2409 // We will now confirm that memcached_mget() returns success, but we will
2410 // then check to make sure that no actual keys are returned.
2411 test_compare(MEMCACHED_SUCCESS
,
2412 memcached_mget(memc
, keys
, key_length
, 4));
2414 memcached_return_t rc
;
2416 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2417 &value_length
, &flags
, &rc
)))
2422 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2424 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2426 test_compare(MEMCACHED_SUCCESS
,
2427 memcached_set(memc
, keys
[x
], key_length
[x
],
2428 insert_data
, VALUE_SIZE_BUG5
,
2429 (time_t)0, (uint32_t)0));
2431 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2433 for (uint32_t x
= 0; x
< 2; x
++)
2435 value
= memcached_get(memc
, keys
[0], key_length
[0],
2436 &value_length
, &flags
, &rc
);
2440 test_compare(MEMCACHED_SUCCESS
,
2441 memcached_mget(memc
, keys
, key_length
, 4));
2442 /* We test for purge of partial complete fetches */
2443 for (count
= 3; count
; count
--)
2445 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2446 &value_length
, &flags
, &rc
);
2447 test_compare(MEMCACHED_SUCCESS
, rc
);
2448 test_memcmp(value
, insert_data
, value_length
);
2449 test_true(value_length
);
2453 delete [] insert_data
;
2455 return TEST_SUCCESS
;
2458 static test_return_t
user_supplied_bug8(memcached_st
*)
2460 memcached_return_t rc
;
2462 memcached_st
*memc_clone
;
2464 memcached_server_st
*servers
;
2465 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";
2467 servers
= memcached_servers_parse(server_list
);
2470 mine
= memcached_create(NULL
);
2471 rc
= memcached_server_push(mine
, servers
);
2472 test_compare(MEMCACHED_SUCCESS
, rc
);
2473 memcached_server_list_free(servers
);
2476 memc_clone
= memcached_clone(NULL
, mine
);
2478 memcached_quit(mine
);
2479 memcached_quit(memc_clone
);
2482 memcached_free(mine
);
2483 memcached_free(memc_clone
);
2485 return TEST_SUCCESS
;
2488 /* Test flag store/retrieve */
2489 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2491 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2492 test_true(insert_data
);
2494 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2496 insert_data
[x
]= (signed char)rand();
2499 memcached_flush(memc
, 0);
2501 const char *keys
= "036790384900";
2502 size_t key_length
= strlen(keys
);
2503 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2504 insert_data
, VALUE_SIZE_BUG5
,
2506 memcached_last_error_message(memc
));
2508 memcached_return_t rc
;
2509 size_t value_length
;
2511 char *value
= memcached_get(memc
, keys
, key_length
,
2512 &value_length
, &flags
, &rc
);
2513 test_compare(245U, flags
);
2517 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2519 char return_key
[MEMCACHED_MAX_KEY
];
2520 size_t return_key_length
;
2522 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2523 &value_length
, &flags
, &rc
);
2524 test_compare(uint32_t(245), flags
);
2527 delete [] insert_data
;
2530 return TEST_SUCCESS
;
2533 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2535 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2536 size_t key_length
[3];
2540 char return_key
[MEMCACHED_MAX_KEY
];
2541 size_t return_key_length
;
2543 size_t return_value_length
;
2546 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2547 key_length
[1]= strlen("fudge&*@#");
2548 key_length
[2]= strlen("for^#@&$not");
2551 for (unsigned int x
= 0; x
< 3; x
++)
2553 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2554 keys
[x
], key_length
[x
],
2555 (time_t)50, (uint32_t)9);
2556 test_compare(MEMCACHED_SUCCESS
, rc
);
2559 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2560 test_compare(MEMCACHED_SUCCESS
, rc
);
2562 /* We need to empty the server before continueing test */
2563 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2564 &return_value_length
, &flags
, &rc
)) != NULL
)
2566 test_true(return_value
);
2570 test_compare(3U, count
);
2572 return TEST_SUCCESS
;
2575 /* We are testing with aggressive timeout to get failures */
2576 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2578 size_t value_length
= 512;
2579 unsigned int set
= 1;
2580 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2582 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2583 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2584 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2586 std::vector
<char> value
;
2587 value
.reserve(value_length
);
2588 for (uint32_t x
= 0; x
< value_length
; x
++)
2590 value
.push_back(char(x
% 127));
2593 for (unsigned int x
= 1; x
<= 100000; ++x
)
2595 memcached_return_t rc
= memcached_set(mclone
,
2596 test_literal_param("foo"),
2597 &value
[0], value
.size(),
2600 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2601 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2602 memcached_strerror(NULL
, rc
));
2604 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2610 memcached_free(mclone
);
2612 return TEST_SUCCESS
;
2616 We are looking failures in the async protocol
2618 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2620 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2622 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2623 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2624 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2626 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2629 std::vector
<char> value
;
2631 for (unsigned int x
= 0; x
< 512; x
++)
2633 value
.push_back(char(x
% 127));
2636 for (unsigned int x
= 1; x
<= 100000; ++x
)
2638 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2642 memcached_free(mclone
);
2644 return TEST_SUCCESS
;
2648 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2650 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2652 memcached_return_t rc
;
2654 size_t value_length
;
2656 uint64_t number_value
;
2658 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2659 &value_length
, &flags
, &rc
);
2661 test_compare(MEMCACHED_NOTFOUND
, rc
);
2663 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2666 /* The binary protocol will set the key if it doesn't exist */
2667 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2669 test_compare(MEMCACHED_SUCCESS
, rc
);
2673 test_compare(MEMCACHED_NOTFOUND
, rc
);
2676 test_compare(MEMCACHED_SUCCESS
,
2677 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2679 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2683 test_compare(MEMCACHED_SUCCESS
,
2684 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2685 test_compare(2UL, number_value
);
2687 return TEST_SUCCESS
;
2691 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2692 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2694 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2696 char key
[] = "key34567890";
2697 memcached_return_t rc
;
2698 size_t overflowSize
;
2700 char commandFirst
[]= "set key34567890 0 0 ";
2701 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2702 size_t commandLength
;
2705 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2707 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2709 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2711 char *overflow
= new (std::nothrow
) char[testSize
];
2712 test_true(overflow
);
2714 memset(overflow
, 'x', testSize
);
2715 rc
= memcached_set(memc
, key
, strlen(key
),
2716 overflow
, testSize
, 0, 0);
2717 test_compare(MEMCACHED_SUCCESS
, rc
);
2721 return TEST_SUCCESS
;
2726 Test values of many different sizes
2727 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2728 set key34567890 0 0 8169 \r\n
2729 is sent followed by buffer of size 8169, followed by 8169
2731 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2733 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2735 std::vector
<char> value
;
2736 value
.reserve(18000);
2737 for (size_t x
= 0; x
< 18000; x
++)
2739 value
.push_back((char) (x
% 127));
2742 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2744 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2745 &value
[0], current_length
,
2746 (time_t)0, (uint32_t)0);
2747 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2749 size_t string_length
;
2751 char *string
= memcached_get(memc
, test_literal_param("foo"),
2752 &string_length
, &flags
, &rc
);
2754 test_compare(MEMCACHED_SUCCESS
, rc
);
2755 test_compare(string_length
, current_length
);
2756 test_memcmp(string
, &value
[0], string_length
);
2761 return TEST_SUCCESS
;
2765 Look for zero length value problems
2767 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2769 for (uint32_t x
= 0; x
< 2; x
++)
2771 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2773 (time_t)0, (uint32_t)0);
2775 test_compare(MEMCACHED_SUCCESS
, rc
);
2779 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2780 &length
, &flags
, &rc
);
2782 test_compare(MEMCACHED_SUCCESS
, rc
);
2787 value
= memcached_get(memc
, test_literal_param("mykey"),
2788 &length
, &flags
, &rc
);
2790 test_compare(MEMCACHED_SUCCESS
, rc
);
2791 test_true(value
== NULL
);
2796 return TEST_SUCCESS
;
2799 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2800 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2802 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2804 (time_t)0, UINT32_MAX
),
2805 memcached_last_error_message(memc
));
2810 memcached_return_t rc
;
2811 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2812 &length
, &flags
, &rc
);
2814 test_compare(MEMCACHED_SUCCESS
, rc
);
2817 test_compare(flags
, UINT32_MAX
);
2819 return TEST_SUCCESS
;
2822 #if !defined(__sun) && !defined(__OpenBSD__)
2823 /* Check the validity of chinese key*/
2824 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2826 const char *key
= "豆瓣";
2827 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2828 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2829 value
, strlen(value
),
2832 test_compare(MEMCACHED_SUCCESS
, rc
);
2836 char *value2
= memcached_get(memc
, key
, strlen(key
),
2837 &length
, &flags
, &rc
);
2839 test_true(length
==strlen(value
));
2840 test_compare(MEMCACHED_SUCCESS
, rc
);
2841 test_memcmp(value
, value2
, length
);
2844 return TEST_SUCCESS
;
2852 static test_return_t
user_supplied_bug19(memcached_st
*)
2854 memcached_return_t res
;
2856 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2858 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2861 memcached_free(memc
);
2863 return TEST_SUCCESS
;
2866 /* CAS test from Andei */
2867 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2869 const char *key
= "abc";
2870 size_t key_len
= strlen("abc");
2872 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2874 test_compare(MEMCACHED_SUCCESS
,
2876 test_literal_param("abc"),
2877 test_literal_param("foobar"),
2878 (time_t)0, (uint32_t)0));
2880 test_compare(MEMCACHED_SUCCESS
,
2881 memcached_mget(memc
, &key
, &key_len
, 1));
2883 memcached_result_st result_obj
;
2884 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2887 memcached_result_create(memc
, &result_obj
);
2888 memcached_return_t status
;
2889 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2892 test_compare(MEMCACHED_SUCCESS
, status
);
2894 memcached_result_free(result
);
2896 return TEST_SUCCESS
;
2899 /* Large mget() of missing keys with binary proto
2901 * If many binary quiet commands (such as getq's in an mget) fill the output
2902 * buffer and the server chooses not to respond, memcached_flush hangs. See
2903 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2906 /* sighandler_t function that always asserts false */
2907 static void fail(int)
2913 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2918 return TEST_SKIPPED
;
2920 void (*oldalarm
)(int);
2922 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2923 test_true(memc_clone
);
2925 /* only binproto uses getq for mget */
2926 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2928 /* empty the cache to ensure misses (hence non-responses) */
2929 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2931 std::vector
<size_t> key_lengths
;
2932 key_lengths
.resize(key_count
);
2933 std::vector
<char *> keys
;
2934 keys
.resize(key_lengths
.size());
2935 for (unsigned int x
= 0; x
< key_lengths
.size(); x
++)
2937 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2938 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2939 test_true(key_length
> 0 and key_length
< MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1);
2940 keys
[x
]= strdup(key
);
2941 key_lengths
[x
]= key_length
;
2944 oldalarm
= signal(SIGALRM
, fail
);
2947 test_compare_got(MEMCACHED_SUCCESS
,
2948 memcached_mget(memc_clone
, &keys
[0], &key_lengths
[0], key_count
), memcached_last_error_message(memc_clone
));
2951 signal(SIGALRM
, oldalarm
);
2953 memcached_return_t rc
;
2955 char return_key
[MEMCACHED_MAX_KEY
];
2956 size_t return_key_length
;
2958 size_t return_value_length
;
2959 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2960 &return_value_length
, &flags
, &rc
)))
2962 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2964 test_compare(MEMCACHED_NOTFOUND
, rc
);
2965 test_zero(return_value_length
);
2966 test_zero(return_key_length
);
2967 test_false(return_key
[0]);
2968 test_false(return_value
);
2970 for (std::vector
<char *>::iterator iter
= keys
.begin();
2977 memcached_free(memc_clone
);
2979 return TEST_SUCCESS
;
2983 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
2985 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2987 /* should work as of r580 */
2988 test_compare(TEST_SUCCESS
,
2989 _user_supplied_bug21(memc
, 10));
2991 /* should fail as of r580 */
2992 test_compare(TEST_SUCCESS
,
2993 _user_supplied_bug21(memc
, 1000));
2995 return TEST_SUCCESS
;
2998 static test_return_t
output_ketama_weighted_keys(memcached_st
*)
3000 memcached_st
*memc
= memcached_create(NULL
);
3004 test_compare(MEMCACHED_SUCCESS
,
3005 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
3007 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3008 test_compare(value
, uint64_t(1));
3010 test_compare(MEMCACHED_SUCCESS
,
3011 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3013 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3014 test_true(value
== MEMCACHED_HASH_MD5
);
3017 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3019 memcached_server_st
*server_pool
;
3020 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");
3021 memcached_server_push(memc
, server_pool
);
3023 // @todo this needs to be refactored to actually test something.
3026 if ((fp
= fopen("ketama_keys.txt", "w")))
3030 printf("cannot write to file ketama_keys.txt");
3031 return TEST_FAILURE
;
3034 for (int x
= 0; x
< 10000; x
++)
3037 snprintf(key
, sizeof(key
), "%d", x
);
3039 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3040 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3041 in_port_t port
= memc
->hosts
[server_idx
].port
;
3042 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3043 memcached_server_instance_st instance
=
3044 memcached_server_instance_by_position(memc
, host_index
);
3048 memcached_server_list_free(server_pool
);
3049 memcached_free(memc
);
3051 return TEST_SUCCESS
;
3055 static test_return_t
result_static(memcached_st
*memc
)
3057 memcached_result_st result
;
3058 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3059 test_false(result
.options
.is_allocated
);
3060 test_true(memcached_is_initialized(&result
));
3061 test_true(result_ptr
);
3062 test_true(result_ptr
== &result
);
3064 memcached_result_free(&result
);
3066 test_false(result
.options
.is_allocated
);
3067 test_false(memcached_is_initialized(&result
));
3069 return TEST_SUCCESS
;
3072 static test_return_t
result_alloc(memcached_st
*memc
)
3074 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3075 test_true(result_ptr
);
3076 test_true(result_ptr
->options
.is_allocated
);
3077 test_true(memcached_is_initialized(result_ptr
));
3078 memcached_result_free(result_ptr
);
3080 return TEST_SUCCESS
;
3083 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3086 pairs_free(global_pairs
);
3088 return TEST_SUCCESS
;
3091 static test_return_t
generate_pairs(memcached_st
*)
3093 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3094 global_count
= GLOBAL_COUNT
;
3096 for (size_t x
= 0; x
< global_count
; x
++)
3098 global_keys
[x
]= global_pairs
[x
].key
;
3099 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3102 return TEST_SUCCESS
;
3105 static test_return_t
generate_large_pairs(memcached_st
*)
3107 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3108 global_count
= GLOBAL2_COUNT
;
3110 for (size_t x
= 0; x
< global_count
; x
++)
3112 global_keys
[x
]= global_pairs
[x
].key
;
3113 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3116 return TEST_SUCCESS
;
3119 static test_return_t
generate_data(memcached_st
*memc
)
3121 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3123 test_compare(global_count
, check_execute
);
3125 return TEST_SUCCESS
;
3128 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3130 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3132 test_compare(check_execute
, global_count
);
3134 // @todo hosts used size stats
3135 memcached_return_t rc
;
3136 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3139 for (uint32_t host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3141 /* This test was changes so that "make test" would work properlly */
3144 memcached_server_instance_st instance
=
3145 memcached_server_instance_by_position(memc
, host_index
);
3147 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3149 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3152 memcached_stat_free(NULL
, stat_p
);
3154 return TEST_SUCCESS
;
3156 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3158 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3159 generate_data(memc
);
3161 return TEST_SUCCESS
;
3164 static test_return_t
get_read_count(memcached_st
*memc
)
3166 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3167 test_true(memc_clone
);
3169 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3173 size_t return_value_length
;
3177 for (size_t x
= count
= 0; x
< global_count
; x
++)
3179 memcached_return_t rc
;
3180 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3181 &return_value_length
, &flags
, &rc
);
3182 if (rc
== MEMCACHED_SUCCESS
)
3193 memcached_free(memc_clone
);
3195 return TEST_SUCCESS
;
3198 static test_return_t
get_read(memcached_st
*memc
)
3200 size_t keys_returned
= 0;
3201 for (size_t x
= 0; x
< global_count
; x
++)
3203 size_t return_value_length
;
3205 memcached_return_t rc
;
3206 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3207 &return_value_length
, &flags
, &rc
);
3209 test_true(return_value);
3210 test_compare(MEMCACHED_SUCCESS, rc);
3212 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3218 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3220 return TEST_SUCCESS
;
3223 static test_return_t
mget_read(memcached_st
*memc
)
3226 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3228 test_compare(MEMCACHED_SUCCESS
,
3229 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3231 // Go fetch the keys and test to see if all of them were returned
3233 unsigned int keys_returned
;
3234 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
));
3235 test_true(keys_returned
> 0);
3236 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3239 return TEST_SUCCESS
;
3242 static test_return_t
mget_read_result(memcached_st
*memc
)
3245 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3247 test_compare(MEMCACHED_SUCCESS
,
3248 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3250 /* Turn this into a help function */
3252 memcached_result_st results_obj
;
3253 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3256 memcached_return_t rc
;
3257 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3259 if (rc
== MEMCACHED_IN_PROGRESS
)
3265 test_compare(MEMCACHED_SUCCESS
, rc
);
3267 test_compare(MEMCACHED_END
, rc
);
3269 memcached_result_free(&results_obj
);
3272 return TEST_SUCCESS
;
3275 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3278 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3280 test_compare(MEMCACHED_SUCCESS
,
3281 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3283 memcached_result_st
*results
= NULL
;
3284 memcached_return_t rc
;
3285 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3288 test_compare(MEMCACHED_SUCCESS
, rc
);
3290 test_compare(MEMCACHED_END
, rc
);
3292 memcached_result_free(results
);
3295 return TEST_SUCCESS
;
3298 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3301 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3303 test_compare(MEMCACHED_SUCCESS
,
3304 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3306 // We will scan for just one key
3308 memcached_result_st results_obj
;
3309 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3311 memcached_return_t rc
;
3312 results
= memcached_fetch_result(memc
, results
, &rc
);
3314 test_compare(MEMCACHED_SUCCESS
, rc
);
3316 memcached_result_free(&results_obj
);
3319 // We already have a read happening, lets start up another one.
3320 test_compare(MEMCACHED_SUCCESS
,
3321 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3323 memcached_result_st results_obj
;
3324 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3326 test_false(memcached_is_allocated(results
));
3328 memcached_return_t rc
;
3329 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3332 test_compare(MEMCACHED_SUCCESS
, rc
);
3334 test_compare(MEMCACHED_END
, rc
);
3336 memcached_result_free(&results_obj
);
3339 return TEST_SUCCESS
;
3342 static test_return_t
mget_read_function(memcached_st
*memc
)
3344 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3346 test_compare(MEMCACHED_SUCCESS
,
3347 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3349 memcached_execute_fn callbacks
[]= { &callback_counter
};
3351 test_compare(MEMCACHED_SUCCESS
,
3352 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3354 return TEST_SUCCESS
;
3357 static test_return_t
delete_generate(memcached_st
*memc
)
3360 for (size_t x
= 0; x
< global_count
; x
++)
3362 if (memcached_success(memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0)))
3367 test_compare_warn_hint(global_count
, total
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3369 return TEST_SUCCESS
;
3372 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3374 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3377 for (size_t x
= 0; x
< global_count
; x
++)
3379 if (memcached_success(memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0)))
3384 test_compare_warn_hint(global_count
, total
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3386 return TEST_SUCCESS
;
3389 static test_return_t
add_host_test1(memcached_st
*memc
)
3391 memcached_return_t rc
;
3392 char servername
[]= "0.example.com";
3394 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3396 test_compare(1U, memcached_server_list_count(servers
));
3398 for (uint32_t x
= 2; x
< 20; x
++)
3400 char buffer
[SMALL_STRING_LEN
];
3402 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3403 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3405 test_compare(MEMCACHED_SUCCESS
, rc
);
3406 test_compare(x
, memcached_server_list_count(servers
));
3409 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3410 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3412 memcached_server_list_free(servers
);
3414 return TEST_SUCCESS
;
3417 static test_return_t
pre_nonblock(memcached_st
*memc
)
3419 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3421 return TEST_SUCCESS
;
3424 static test_return_t
pre_cork(memcached_st
*memc
)
3427 return TEST_SKIPPED
;
3430 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3431 return TEST_SUCCESS
;
3433 return TEST_SKIPPED
;
3436 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3439 return TEST_SKIPPED
;
3441 test_return_t test_rc
;
3442 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3445 return pre_nonblock(memc
);
3448 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3450 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3451 test_true(memc_clone
);
3453 // The memcached_version needs to be done on a clone, because the server
3454 // will not toggle protocol on an connection.
3455 memcached_version(memc_clone
);
3457 memcached_return_t rc
= MEMCACHED_FAILURE
;
3458 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3460 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3461 test_compare(MEMCACHED_SUCCESS
,
3462 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3463 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3467 memcached_free(memc_clone
);
3468 return TEST_SKIPPED
;
3471 memcached_free(memc_clone
);
3473 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3476 static test_return_t
pre_murmur(memcached_st
*memc
)
3478 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3479 return TEST_SUCCESS
;
3482 static test_return_t
pre_jenkins(memcached_st
*memc
)
3484 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3486 return TEST_SKIPPED
;
3490 static test_return_t
pre_md5(memcached_st
*memc
)
3492 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3494 return TEST_SUCCESS
;
3497 static test_return_t
pre_crc(memcached_st
*memc
)
3499 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3501 return TEST_SUCCESS
;
3504 static test_return_t
pre_hsieh(memcached_st
*memc
)
3506 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
));
3507 return TEST_SUCCESS
;
3510 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3512 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3514 return TEST_SUCCESS
;
3517 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3519 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
));
3521 return TEST_SUCCESS
;
3524 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3526 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3528 return TEST_SUCCESS
;
3531 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3533 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3535 return TEST_SUCCESS
;
3538 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3540 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3541 test_compare(MEMCACHED_SUCCESS
, rc
);
3543 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3544 test_compare(value
, uint64_t(1));
3546 return TEST_SUCCESS
;
3549 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3551 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3552 test_compare(MEMCACHED_SUCCESS
, rc
);
3554 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3555 test_compare(value
, uint64_t(1));
3557 test_compare(MEMCACHED_SUCCESS
,
3558 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3560 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3561 test_compare(MEMCACHED_HASH_MD5
, memcached_hash_t(value
));
3563 return TEST_SUCCESS
;
3566 static test_return_t
pre_replication(memcached_st
*memc
)
3568 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3571 * Make sure that we store the item on all servers
3572 * (master + replicas == number of servers)
3574 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3575 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3577 return TEST_SUCCESS
;
3581 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3583 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3585 return pre_nonblock(memc
);
3589 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3593 #ifdef HARD_MALLOC_TESTS
3594 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3602 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3606 #ifdef HARD_MALLOC_TESTS
3607 void *ret
= malloc(size
+ 8);
3610 ret
= (void*)((caddr_t
)ret
+ 8);
3613 void *ret
= malloc(size
);
3618 memset(ret
, 0xff, size
);
3625 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3627 #ifdef HARD_MALLOC_TESTS
3628 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3629 void *nmem
= realloc(real_ptr
, size
+ 8);
3634 ret
= (void*)((caddr_t
)nmem
+ 8);
3640 return realloc(mem
, size
);
3645 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3647 #ifdef HARD_MALLOC_TESTS
3648 void *mem
= my_malloc(ptr
, nelem
* size
);
3651 memset(mem
, 0, nelem
* size
);
3657 return calloc(nelem
, size
);
3661 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3663 memcached_return_t rc
;
3664 const char *key
= "mine";
3667 /* Make sure be default none exists */
3668 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3670 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3672 /* Test a clean set */
3673 test_compare(MEMCACHED_SUCCESS
,
3674 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3676 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3678 test_memcmp(value
, key
, 4);
3679 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3681 /* Test that we can turn it off */
3682 test_compare(MEMCACHED_SUCCESS
,
3683 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3685 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3687 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3689 /* Now setup for main test */
3690 test_compare(MEMCACHED_SUCCESS
,
3691 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3693 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3695 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3696 test_memcmp(value
, key
, 4);
3698 /* Set to Zero, and then Set to something too large */
3701 memset(long_key
, 0, 255);
3703 test_compare(MEMCACHED_SUCCESS
,
3704 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3706 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3708 test_compare(MEMCACHED_SUCCESS
, rc
);
3710 /* Test a long key for failure */
3711 /* TODO, extend test to determine based on setting, what result should be */
3712 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3713 test_compare(MEMCACHED_SUCCESS
,
3714 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3716 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3717 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3718 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3719 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3721 /* Test for a bad prefix, but with a short key */
3722 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3723 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3725 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3726 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3729 return TEST_SUCCESS
;
3732 static test_return_t
set_namespace(memcached_st
*memc
)
3734 memcached_return_t rc
;
3735 const char *key
= "mine";
3738 // Make sure we default to a null namespace
3739 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3741 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3743 /* Test a clean set */
3744 test_compare(MEMCACHED_SUCCESS
,
3745 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3747 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3749 test_memcmp(value
, key
, 4);
3750 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3752 return TEST_SUCCESS
;
3755 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3757 test_return_if(pre_binary(memc
));
3758 test_return_if(set_namespace(memc
));
3760 return TEST_SUCCESS
;
3763 #ifdef MEMCACHED_ENABLE_DEPRECATED
3764 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3766 void *test_ptr
= NULL
;
3769 memcached_malloc_fn malloc_cb
=
3770 (memcached_malloc_fn
)my_malloc
;
3771 cb_ptr
= *(void **)&malloc_cb
;
3772 memcached_return_t rc
;
3774 test_compare(MEMCACHED_SUCCESS
,
3775 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3776 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3777 test_compare(MEMCACHED_SUCCESS
, rc
);
3778 test_true(test_ptr
== cb_ptr
);
3782 memcached_realloc_fn realloc_cb
=
3783 (memcached_realloc_fn
)my_realloc
;
3784 cb_ptr
= *(void **)&realloc_cb
;
3785 memcached_return_t rc
;
3787 test_compare(MEMCACHED_SUCCESS
,
3788 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3789 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3790 test_compare(MEMCACHED_SUCCESS
, rc
);
3791 test_true(test_ptr
== cb_ptr
);
3795 memcached_free_fn free_cb
=
3796 (memcached_free_fn
)my_free
;
3797 cb_ptr
= *(void **)&free_cb
;
3798 memcached_return_t rc
;
3800 test_compare(MEMCACHED_SUCCESS
,
3801 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3802 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3803 test_compare(MEMCACHED_SUCCESS
, rc
);
3804 test_true(test_ptr
== cb_ptr
);
3807 return TEST_SUCCESS
;
3812 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3814 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3815 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3816 my_realloc
, my_calloc
, NULL
));
3818 test_compare(MEMCACHED_SUCCESS
,
3819 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3820 my_realloc
, my_calloc
, NULL
));
3822 memcached_malloc_fn mem_malloc
;
3823 memcached_free_fn mem_free
;
3824 memcached_realloc_fn mem_realloc
;
3825 memcached_calloc_fn mem_calloc
;
3826 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3827 &mem_realloc
, &mem_calloc
);
3829 test_true(mem_malloc
== my_malloc
);
3830 test_true(mem_realloc
== my_realloc
);
3831 test_true(mem_calloc
== my_calloc
);
3832 test_true(mem_free
== my_free
);
3834 return TEST_SUCCESS
;
3837 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3840 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3841 memcached_hash_t hash
;
3842 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3843 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3846 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3847 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3849 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3851 if (hash
!= MEMCACHED_HASH_CRC
)
3852 return TEST_SKIPPED
;
3854 return TEST_SUCCESS
;
3857 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3860 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3861 memcached_hash_t hash
;
3862 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3863 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3868 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3869 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3871 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3873 if (hash
!= MEMCACHED_HASH_HSIEH
)
3874 return TEST_SKIPPED
;
3877 return TEST_SUCCESS
;
3880 static test_return_t
enable_cas(memcached_st
*memc
)
3882 unsigned int set
= 1;
3884 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3886 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3888 return TEST_SUCCESS
;
3891 return TEST_SKIPPED
;
3894 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3896 memcached_version(memc
);
3898 memcached_server_instance_st instance
=
3899 memcached_server_instance_by_position(memc
, 0);
3901 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3902 or instance
->minor_version
> 2)
3904 return TEST_SUCCESS
;
3907 return TEST_SKIPPED
;
3910 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3914 memcached_servers_reset(memc
);
3915 const char *socket_file
= default_socket();
3917 test_skip(0, stat(socket_file
, &buf
));
3919 test_compare(MEMCACHED_SUCCESS
,
3920 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
3922 return TEST_SUCCESS
;
3925 static test_return_t
pre_nodelay(memcached_st
*memc
)
3927 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3928 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3930 return TEST_SUCCESS
;
3933 static test_return_t
pre_settimer(memcached_st
*memc
)
3935 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3936 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3938 return TEST_SUCCESS
;
3941 static test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3943 const uint64_t timeout
= 100; // Not using, just checking that it sets
3945 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3947 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3949 return TEST_SUCCESS
;
3952 static test_return_t
noreply_test(memcached_st
*memc
)
3954 test_compare(MEMCACHED_SUCCESS
,
3955 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3956 test_compare(MEMCACHED_SUCCESS
,
3957 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3958 test_compare(MEMCACHED_SUCCESS
,
3959 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3960 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3961 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3962 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3964 memcached_return_t ret
;
3965 for (int count
= 0; count
< 5; ++count
)
3967 for (size_t x
= 0; x
< 100; ++x
)
3970 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3971 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3973 size_t len
= (size_t)check_length
;
3978 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3981 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3984 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3987 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3990 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3996 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, ret
));
4000 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4001 ** API and is _ONLY_ done this way to verify that the library works the
4002 ** way it is supposed to do!!!!
4005 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4007 memcached_server_instance_st instance
=
4008 memcached_server_instance_by_position(memc
, x
);
4009 no_msg
+=(int)(instance
->cursor_active
);
4012 test_true(no_msg
== 0);
4013 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4016 ** Now validate that all items was set properly!
4018 for (size_t x
= 0; x
< 100; ++x
)
4022 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4024 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4026 size_t len
= (size_t)check_length
;
4029 char* value
=memcached_get(memc
, key
, strlen(key
),
4030 &length
, &flags
, &ret
);
4031 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
4034 case 0: /* FALLTHROUGH */
4035 case 1: /* FALLTHROUGH */
4037 test_true(strncmp(value
, key
, len
) == 0);
4038 test_true(len
== length
);
4041 test_true(length
== len
* 2);
4044 test_true(length
== len
* 3);
4054 /* Try setting an illegal cas value (should not return an error to
4055 * the caller (because we don't expect a return message from the server)
4057 const char* keys
[]= {"0"};
4058 size_t lengths
[]= {1};
4061 memcached_result_st results_obj
;
4062 memcached_result_st
*results
;
4063 test_compare(MEMCACHED_SUCCESS
,
4064 memcached_mget(memc
, keys
, lengths
, 1));
4066 results
= memcached_result_create(memc
, &results_obj
);
4068 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4070 test_compare(MEMCACHED_SUCCESS
, ret
);
4071 uint64_t cas
= memcached_result_cas(results
);
4072 memcached_result_free(&results_obj
);
4074 test_compare(MEMCACHED_SUCCESS
,
4075 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4078 * The item will have a new cas value, so try to set it again with the old
4079 * value. This should fail!
4081 test_compare(MEMCACHED_SUCCESS
,
4082 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4083 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4084 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4085 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4088 return TEST_SUCCESS
;
4091 static test_return_t
analyzer_test(memcached_st
*memc
)
4093 memcached_return_t rc
;
4094 memcached_analysis_st
*report
;
4096 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4097 test_compare(MEMCACHED_SUCCESS
, rc
);
4098 test_true(memc_stat
);
4100 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4101 test_compare(MEMCACHED_SUCCESS
, rc
);
4105 memcached_stat_free(NULL
, memc_stat
);
4107 return TEST_SUCCESS
;
4110 /* Count the objects */
4112 static test_return_t
dump_test(memcached_st
*memc
)
4114 /* No support for Binary protocol yet */
4115 test_skip(false, memc
->flags
.binary_protocol
);
4117 test_compare(TEST_SUCCESS
, set_test3(memc
));
4119 // confirm_key_count() call dump
4120 size_t counter
= confirm_key_count(memc
);
4122 /* We may have more then 32 if our previous flush has not completed */
4123 test_true(counter
>= 32);
4125 return TEST_SUCCESS
;
4128 static test_return_t
util_version_test(memcached_st
*memc
)
4130 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
4131 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
4133 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4135 // We expect failure
4138 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4139 fprintf(stderr
, "\nDumping Server Information\n\n");
4140 memcached_server_fn callbacks
[1];
4142 callbacks
[0]= dump_server_information
;
4143 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4144 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4146 test_true(if_successful
== false);
4148 memcached_server_instance_st instance
=
4149 memcached_server_instance_by_position(memc
, 0);
4151 memcached_version(memc
);
4153 // We only use one binary when we test, so this should be just fine.
4154 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4155 test_true(if_successful
== true);
4157 if (instance
->micro_version
> 0)
4159 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4161 else if (instance
->minor_version
> 0)
4163 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4165 else if (instance
->major_version
> 0)
4167 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4170 test_true(if_successful
== true);
4172 if (instance
->micro_version
> 0)
4174 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4176 else if (instance
->minor_version
> 0)
4178 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4180 else if (instance
->major_version
> 0)
4182 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4185 test_true(if_successful
== false);
4187 return TEST_SUCCESS
;
4190 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4192 memcached_return_t rc
;
4193 memcached_server_instance_st instance
=
4194 memcached_server_instance_by_position(memc
, 0);
4196 // Test both the version that returns a code, and the one that does not.
4197 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4198 memcached_server_port(instance
) -1, NULL
) == -1);
4200 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4201 memcached_server_port(instance
) -1, &rc
) == -1);
4202 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4204 return TEST_SUCCESS
;
4208 static test_return_t
getpid_test(memcached_st
*memc
)
4210 memcached_return_t rc
;
4211 memcached_server_instance_st instance
=
4212 memcached_server_instance_by_position(memc
, 0);
4214 // Test both the version that returns a code, and the one that does not.
4215 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4216 memcached_server_port(instance
), NULL
) > -1);
4218 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4219 memcached_server_port(instance
), &rc
) > -1);
4220 test_compare(MEMCACHED_SUCCESS
, rc
);
4222 return TEST_SUCCESS
;
4225 static test_return_t
ping_test(memcached_st
*memc
)
4227 memcached_return_t rc
;
4228 memcached_server_instance_st instance
=
4229 memcached_server_instance_by_position(memc
, 0);
4231 // Test both the version that returns a code, and the one that does not.
4232 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4233 memcached_server_port(instance
), NULL
));
4235 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4236 memcached_server_port(instance
), &rc
));
4238 test_compare(MEMCACHED_SUCCESS
, rc
);
4240 return TEST_SUCCESS
;
4245 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4249 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4250 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4251 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4252 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4253 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4254 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4255 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4256 #ifdef HAVE_HSIEH_HASH
4257 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4259 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4260 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4261 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4263 return TEST_SUCCESS
;
4267 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4269 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4271 test_compare(MEMCACHED_SUCCESS
,
4272 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4273 (uint64_t)MEMCACHED_HASH_HSIEH
));
4275 return TEST_SUCCESS
;
4278 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4280 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4282 test_compare(MEMCACHED_SUCCESS
,
4283 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
4285 return TEST_SUCCESS
;
4288 static test_return_t
one_at_a_time_run (memcached_st
*)
4293 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4295 test_compare(one_at_a_time_values
[x
],
4296 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
4299 return TEST_SUCCESS
;
4302 static test_return_t
md5_run (memcached_st
*)
4307 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4309 test_compare(md5_values
[x
],
4310 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
4313 return TEST_SUCCESS
;
4316 static test_return_t
crc_run (memcached_st
*)
4321 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4323 test_compare(crc_values
[x
],
4324 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
4327 return TEST_SUCCESS
;
4330 static test_return_t
fnv1_64_run (memcached_st
*)
4332 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
4337 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4339 test_compare(fnv1_64_values
[x
],
4340 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
4343 return TEST_SUCCESS
;
4346 static test_return_t
fnv1a_64_run (memcached_st
*)
4348 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
4353 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4355 test_compare(fnv1a_64_values
[x
],
4356 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
4359 return TEST_SUCCESS
;
4362 static test_return_t
fnv1_32_run (memcached_st
*)
4367 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4369 test_compare(fnv1_32_values
[x
],
4370 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
4373 return TEST_SUCCESS
;
4376 static test_return_t
fnv1a_32_run (memcached_st
*)
4381 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4383 test_compare(fnv1a_32_values
[x
],
4384 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
4387 return TEST_SUCCESS
;
4390 static test_return_t
hsieh_run (memcached_st
*)
4392 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4397 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4399 test_compare(hsieh_values
[x
],
4400 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
4403 return TEST_SUCCESS
;
4406 static test_return_t
murmur_run (memcached_st
*)
4408 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4410 #ifdef WORDS_BIGENDIAN
4411 (void)murmur_values
;
4412 return TEST_SKIPPED
;
4417 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4419 test_compare(murmur_values
[x
],
4420 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
4423 return TEST_SUCCESS
;
4427 static test_return_t
jenkins_run (memcached_st
*)
4432 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4434 test_compare(jenkins_values
[x
],
4435 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
4438 return TEST_SUCCESS
;
4441 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
4443 return libhashkit_md5(string
, string_length
);
4446 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
4448 return libhashkit_crc32(string
, string_length
);
4451 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4457 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
4459 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};
4460 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};
4462 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4464 hashkit_clone(&new_kit
, kit
);
4465 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4467 memcached_set_hashkit(memc
, &new_kit
);
4470 Verify Setting the hash.
4472 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4476 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4477 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4482 Now check memcached_st.
4484 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4488 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4489 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4492 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4494 memcached_set_hashkit(memc
, &new_kit
);
4497 Verify Setting the hash.
4499 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4503 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4504 test_true(crc_values
[x
] == hash_val
);
4507 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4511 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4512 test_compare(crc_hosts
[x
], hash_val
);
4515 memcached_free(memc
);
4517 return TEST_SUCCESS
;
4521 Test case adapted from John Gorman <johngorman2@gmail.com>
4523 We are testing the error condition when we connect to a server via memcached_get()
4524 but find that the server is not available.
4526 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4528 const char *key
= "MemcachedLives";
4531 memcached_return rc
;
4534 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4536 // See if memcached is reachable.
4537 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4541 test_true(memcached_failed(rc
));
4543 memcached_free(tl_memc_h
);
4545 return TEST_SUCCESS
;
4549 We connect to a server which exists, but search for a key that does not exist.
4551 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4553 const char *key
= "MemcachedKeyNotEXIST";
4556 memcached_return rc
;
4558 // See if memcached is reachable.
4559 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4563 test_compare(MEMCACHED_NOTFOUND
, rc
);
4565 return TEST_SUCCESS
;
4569 Test case adapted from John Gorman <johngorman2@gmail.com>
4571 We are testing the error condition when we connect to a server via memcached_get_by_key()
4572 but find that the server is not available.
4574 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4577 memcached_st
*tl_memc_h
;
4578 memcached_server_st
*servers
;
4580 const char *key
= "MemcachedLives";
4583 memcached_return rc
;
4587 tl_memc_h
= memcached_create(NULL
);
4588 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4589 memcached_server_push(tl_memc_h
, servers
);
4590 memcached_server_list_free(servers
);
4592 // See if memcached is reachable.
4593 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4597 test_true(memcached_failed(rc
));
4599 memcached_free(tl_memc_h
);
4601 return TEST_SUCCESS
;
4605 We connect to a server which exists, but search for a key that does not exist.
4607 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4609 const char *key
= "MemcachedKeyNotEXIST";
4612 memcached_return rc
;
4615 // See if memcached is reachable.
4616 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4620 test_compare(MEMCACHED_NOTFOUND
, rc
);
4622 return TEST_SUCCESS
;
4625 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4627 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4629 const char *key
= "regression_bug_434484";
4630 size_t keylen
= strlen(key
);
4632 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4633 test_compare(MEMCACHED_NOTSTORED
, ret
);
4635 size_t size
= 2048 * 1024;
4636 char *data
= (char*)calloc(1, size
);
4638 test_compare(MEMCACHED_E2BIG
,
4639 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4642 return TEST_SUCCESS
;
4645 static test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4647 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4649 memcached_return_t rc
;
4651 memcached_execute_fn callbacks
[]= { &callback_counter
};
4654 * I only want to hit only _one_ server so I know the number of requests I'm
4655 * sending in the pipleine to the server. Let's try to do a multiget of
4656 * 1024 (that should satisfy most users don't you think?). Future versions
4657 * will include a mget_execute function call if you need a higher number.
4659 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4661 const size_t max_keys
= 1024;
4662 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4663 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4665 for (size_t x
= 0; x
< max_keys
; ++x
)
4669 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4675 * Run two times.. the first time we should have 100% cache miss,
4676 * and the second time we should have 100% cache hits
4678 for (size_t y
= 0; y
< 2; y
++)
4680 test_compare(MEMCACHED_SUCCESS
,
4681 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4683 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4684 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4688 /* The first iteration should give me a 100% cache miss. verify that*/
4689 char blob
[1024]= { 0 };
4691 test_false(counter
);
4693 for (size_t x
= 0; x
< max_keys
; ++x
)
4695 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4696 blob
, sizeof(blob
), 0, 0);
4697 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4702 /* Verify that we received all of the key/value pairs */
4703 test_compare(counter
, max_keys
);
4707 /* Release allocated resources */
4708 for (size_t x
= 0; x
< max_keys
; ++x
)
4715 memcached_free(memc
);
4717 return TEST_SUCCESS
;
4720 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4722 memcached_return_t rc
;
4723 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4724 test_compare(MEMCACHED_SUCCESS
, rc
);
4726 return regression_bug_434843(memc
);
4729 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4731 memcached_return_t rc
;
4732 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4733 test_compare(MEMCACHED_SUCCESS
, rc
);
4735 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4736 test_compare(MEMCACHED_SUCCESS
, rc
);
4737 test_true(bytes_str
);
4738 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4740 test_compare(MEMCACHED_SUCCESS
, rc
);
4741 test_true(bytes_read_str
);
4743 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4744 "bytes_written", &rc
);
4745 test_compare(MEMCACHED_SUCCESS
, rc
);
4746 test_true(bytes_written_str
);
4748 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4749 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4750 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4752 test_true(bytes
!= bytes_read
);
4753 test_true(bytes
!= bytes_written
);
4755 /* Release allocated resources */
4757 free(bytes_read_str
);
4758 free(bytes_written_str
);
4759 memcached_stat_free(NULL
, memc_stat
);
4761 return TEST_SUCCESS
;
4765 * The test case isn't obvious so I should probably document why
4766 * it works the way it does. Bug 442914 was caused by a bug
4767 * in the logic in memcached_purge (it did not handle the case
4768 * where the number of bytes sent was equal to the watermark).
4769 * In this test case, create messages so that we hit that case
4770 * and then disable noreply mode and issue a new command to
4771 * verify that it isn't stuck. If we change the format for the
4772 * delete command or the watermarks, we need to update this
4775 static test_return_t
regression_bug_442914(memcached_st
*memc
)
4777 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4778 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4780 uint32_t number_of_hosts
= memcached_server_count(memc
);
4781 memc
->number_of_hosts
= 1;
4786 for (uint32_t x
= 0; x
< 250; ++x
)
4788 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4789 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4790 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4793 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
4796 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4797 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4799 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4800 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
4802 memc
->number_of_hosts
= number_of_hosts
;
4804 return TEST_SUCCESS
;
4807 static test_return_t
regression_bug_447342(memcached_st
*memc
)
4809 memcached_server_instance_st instance_one
;
4810 memcached_server_instance_st instance_two
;
4812 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4813 return TEST_SKIPPED
;
4815 test_compare(MEMCACHED_SUCCESS
,
4816 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4818 const unsigned int max_keys
= 100;
4819 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4820 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4822 for (unsigned int x
= 0; x
< max_keys
; ++x
)
4826 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4829 test_compare(MEMCACHED_SUCCESS
,
4830 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
4834 ** We are using the quiet commands to store the replicas, so we need
4835 ** to ensure that all of them are processed before we can continue.
4836 ** In the test we go directly from storing the object to trying to
4837 ** receive the object from all of the different servers, so we
4838 ** could end up in a race condition (the memcached server hasn't yet
4839 ** processed the quiet command from the replication set when it process
4840 ** the request from the other client (created by the clone)). As a
4841 ** workaround for that we call memcached_quit to send the quit command
4842 ** to the server and wait for the response ;-) If you use the test code
4843 ** as an example for your own code, please note that you shouldn't need
4846 memcached_quit(memc
);
4848 /* Verify that all messages are stored, and we didn't stuff too much
4851 test_compare(MEMCACHED_SUCCESS
,
4852 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4854 unsigned int counter
= 0;
4855 memcached_execute_fn callbacks
[]= { &callback_counter
};
4856 test_compare(MEMCACHED_SUCCESS
,
4857 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4859 /* Verify that we received all of the key/value pairs */
4860 test_compare(counter
, max_keys
);
4862 memcached_quit(memc
);
4864 * Don't do the following in your code. I am abusing the internal details
4865 * within the library, and this is not a supported interface.
4866 * This is to verify correct behavior in the library. Fake that two servers
4869 instance_one
= memcached_server_instance_by_position(memc
, 0);
4870 instance_two
= memcached_server_instance_by_position(memc
, 2);
4871 in_port_t port0
= instance_one
->port
;
4872 in_port_t port2
= instance_two
->port
;
4874 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4875 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4877 test_compare(MEMCACHED_SUCCESS
,
4878 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4881 test_compare(MEMCACHED_SUCCESS
,
4882 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4883 test_compare(counter
, (unsigned int)max_keys
);
4885 /* restore the memc handle */
4886 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4887 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4889 memcached_quit(memc
);
4891 /* Remove half of the objects */
4892 for (size_t x
= 0; x
< max_keys
; ++x
)
4896 test_compare(MEMCACHED_SUCCESS
,
4897 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
4901 memcached_quit(memc
);
4902 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4903 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4905 /* now retry the command, this time we should have cache misses */
4906 test_compare(MEMCACHED_SUCCESS
,
4907 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4910 test_compare(MEMCACHED_SUCCESS
,
4911 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4912 test_compare(counter
, (unsigned int)(max_keys
>> 1));
4914 /* Release allocated resources */
4915 for (size_t x
= 0; x
< max_keys
; ++x
)
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 return TEST_SUCCESS
;
4929 static test_return_t
regression_bug_463297(memcached_st
*memc
)
4931 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4932 test_true(memc_clone
);
4933 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4935 memcached_server_instance_st instance
=
4936 memcached_server_instance_by_position(memc_clone
, 0);
4938 if (instance
->major_version
> 1 ||
4939 (instance
->major_version
== 1 &&
4940 instance
->minor_version
> 2))
4942 /* Binary protocol doesn't support deferred delete */
4943 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4944 test_true(bin_clone
);
4945 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4946 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4947 memcached_free(bin_clone
);
4949 memcached_quit(memc_clone
);
4951 /* If we know the server version, deferred delete should fail
4952 * with invalid arguments */
4953 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4955 /* If we don't know the server version, we should get a protocol error */
4956 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4958 /* but there is a bug in some of the memcached servers (1.4) that treats
4959 * the counter as noreply so it doesn't send the proper error message
4961 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4963 /* And buffered mode should be disabled and we should get protocol error */
4964 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4965 rc
= memcached_delete(memc
, "foo", 3, 1);
4966 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4968 /* Same goes for noreply... */
4969 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4970 rc
= memcached_delete(memc
, "foo", 3, 1);
4971 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4973 /* but a normal request should go through (and be buffered) */
4974 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4975 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4977 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4978 /* unbuffered noreply should be success */
4979 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4980 /* unbuffered with reply should be not found... */
4981 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4982 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4985 memcached_free(memc_clone
);
4986 return TEST_SUCCESS
;
4990 /* Test memcached_server_get_last_disconnect
4991 * For a working server set, shall be NULL
4992 * For a set of non existing server, shall not be NULL
4994 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4996 memcached_return_t rc
;
4997 memcached_server_instance_st disconnected_server
;
4999 /* With the working set of server */
5000 const char *key
= "marmotte";
5001 const char *value
= "milka";
5003 memcached_reset_last_disconnected_server(memc
);
5004 test_false(memc
->last_disconnected_server
);
5005 rc
= memcached_set(memc
, key
, strlen(key
),
5006 value
, strlen(value
),
5007 (time_t)0, (uint32_t)0);
5008 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5010 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5011 test_false(disconnected_server
);
5013 /* With a non existing server */
5015 memcached_server_st
*servers
;
5017 const char *server_list
= "localhost:9";
5019 servers
= memcached_servers_parse(server_list
);
5021 mine
= memcached_create(NULL
);
5022 rc
= memcached_server_push(mine
, servers
);
5023 test_compare(MEMCACHED_SUCCESS
, rc
);
5024 memcached_server_list_free(servers
);
5027 rc
= memcached_set(mine
, key
, strlen(key
),
5028 value
, strlen(value
),
5029 (time_t)0, (uint32_t)0);
5030 test_true(memcached_failed(rc
));
5032 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5033 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5034 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5035 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5037 memcached_quit(mine
);
5038 memcached_free(mine
);
5040 return TEST_SUCCESS
;
5043 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5045 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5046 char buffer
[BUFSIZ
];
5048 test_compare(MEMCACHED_SUCCESS
,
5049 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5051 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5054 // We will just use the error strings as our keys
5055 uint32_t counter
= 100;
5058 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5060 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5061 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5062 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
5064 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5065 test_true(disconnected_server
);
5066 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5067 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5071 memcached_reset_last_disconnected_server(memc
);
5076 memcached_free(memc
);
5078 return TEST_SUCCESS
;
5081 static test_return_t
test_verbosity(memcached_st
*memc
)
5083 memcached_verbosity(memc
, 3);
5085 return TEST_SUCCESS
;
5089 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5090 const char *key
, size_t key_length
,
5091 const char *value
, size_t value_length
,
5101 return MEMCACHED_SUCCESS
;
5104 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5106 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5107 test_compare(MEMCACHED_SUCCESS
, rc
);
5109 test_compare(MEMCACHED_SUCCESS
,
5110 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
5112 test_compare(MEMCACHED_SUCCESS
,
5113 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
5115 test_compare(MEMCACHED_SUCCESS
,
5116 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
5118 return TEST_SUCCESS
;
5122 * This test ensures that the failure counter isn't incremented during
5123 * normal termination of the memcached instance.
5125 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5127 memcached_return_t rc
;
5128 memcached_server_instance_st instance
;
5130 /* Set value to force connection to the server */
5131 const char *key
= "marmotte";
5132 const char *value
= "milka";
5135 * Please note that I'm abusing the internal structures in libmemcached
5136 * in a non-portable way and you shouldn't be doing this. I'm only
5137 * doing this in order to verify that the library works the way it should
5139 uint32_t number_of_hosts
= memcached_server_count(memc
);
5140 memc
->number_of_hosts
= 1;
5142 /* Ensure that we are connected to the server by setting a value */
5143 rc
= memcached_set(memc
, key
, strlen(key
),
5144 value
, strlen(value
),
5145 (time_t)0, (uint32_t)0);
5146 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5149 instance
= memcached_server_instance_by_position(memc
, 0);
5150 /* The test is to see that the memcached_quit doesn't increase the
5151 * the server failure conter, so let's ensure that it is zero
5152 * before sending quit
5154 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5156 memcached_quit(memc
);
5158 /* Verify that it memcached_quit didn't increment the failure counter
5159 * Please note that this isn't bullet proof, because an error could
5162 test_zero(instance
->server_failure_counter
);
5164 /* restore the instance */
5165 memc
->number_of_hosts
= number_of_hosts
;
5167 return TEST_SUCCESS
;
5171 * This tests ensures expected disconnections (for some behavior changes
5172 * for instance) do not wrongly increase failure counter
5174 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5176 /* Set value to force connection to the server */
5177 const char *key
= "marmotte";
5178 const char *value
= "milka";
5180 test_compare_hint(MEMCACHED_SUCCESS
,
5181 memcached_set(memc
, key
, strlen(key
),
5182 value
, strlen(value
),
5183 (time_t)0, (uint32_t)0),
5184 memcached_last_error_message(memc
));
5187 /* put failure limit to 1 */
5188 test_compare(MEMCACHED_SUCCESS
,
5189 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
5191 /* Put a retry timeout to effectively activate failure_limit effect */
5192 test_compare(MEMCACHED_SUCCESS
,
5193 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
5195 /* change behavior that triggers memcached_quit()*/
5196 test_compare(MEMCACHED_SUCCESS
,
5197 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
5200 /* Check if we still are connected */
5202 size_t string_length
;
5203 memcached_return rc
;
5204 char *string
= memcached_get(memc
, key
, strlen(key
),
5205 &string_length
, &flags
, &rc
);
5207 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5211 return TEST_SUCCESS
;
5216 * Test that ensures mget_execute does not end into recursive calls that finally fails
5218 static test_return_t
regression_bug_490486(memcached_st
*original_memc
)
5222 return TEST_SKIPPED
; // My MAC can't handle this test
5225 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
5228 * I only want to hit _one_ server so I know the number of requests I'm
5229 * sending in the pipeline.
5231 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
5234 size_t max_keys
= 20480;
5236 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5237 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5239 /* First add all of the items.. */
5240 char blob
[1024]= { 0 };
5241 for (size_t x
= 0; x
< max_keys
; ++x
)
5244 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5247 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5248 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5253 /* Try to get all of them with a large multiget */
5255 memcached_execute_function callbacks
[]= { &callback_counter
};
5256 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5257 (size_t)max_keys
, callbacks
, &counter
, 1);
5258 test_compare(MEMCACHED_SUCCESS
, rc
);
5260 char* the_value
= NULL
;
5261 char the_key
[MEMCACHED_MAX_KEY
];
5262 size_t the_key_length
;
5263 size_t the_value_length
;
5267 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5269 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5275 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5278 test_compare(MEMCACHED_END
, rc
);
5280 /* Verify that we got all of the items */
5281 test_compare(counter
, max_keys
);
5284 /* Release all allocated resources */
5285 for (size_t x
= 0; x
< max_keys
; ++x
)
5292 memcached_free(memc
);
5294 return TEST_SUCCESS
;
5297 static test_return_t
regression_bug_583031(memcached_st
*)
5299 memcached_st
*memc
= memcached_create(NULL
);
5301 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5303 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5304 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5305 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5306 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5307 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5308 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5310 memcached_return_t rc
;
5314 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5318 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5320 memcached_free(memc
);
5322 return TEST_SUCCESS
;
5325 static test_return_t
regression_bug_581030(memcached_st
*)
5328 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5329 test_false(local_stat
);
5331 memcached_stat_free(NULL
, NULL
);
5334 return TEST_SUCCESS
;
5337 #define regression_bug_655423_COUNT 6000
5338 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5340 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5341 memc
= NULL
; // Just to make sure it is not used
5346 return TEST_SKIPPED
;
5349 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5350 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5351 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5352 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5354 memset(payload
, int('x'), sizeof(payload
));
5356 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5358 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5359 snprintf(key
, sizeof(key
), "%u", x
);
5361 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5364 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5366 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5367 snprintf(key
, sizeof(key
), "%u", x
);
5369 size_t value_length
;
5370 memcached_return_t rc
;
5371 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5373 if (rc
== MEMCACHED_NOTFOUND
)
5376 test_zero(value_length
);
5380 test_compare(MEMCACHED_SUCCESS
, rc
);
5382 test_compare(100LLU, value_length
);
5386 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5387 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5388 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5390 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5391 snprintf(key
, sizeof(key
), "%u", x
);
5393 keys
[x
]= strdup(key
);
5395 key_length
[x
]= strlen(key
);
5396 test_true(key_length
[x
]);
5399 test_compare(MEMCACHED_SUCCESS
,
5400 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5403 memcached_result_st
*result
= NULL
;
5404 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5406 test_compare(size_t(100), memcached_result_length(result
));
5410 test_true(count
> 100); // If we don't get back atleast this, something is up
5412 /* Release all allocated resources */
5413 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5421 memcached_free(clone
);
5423 return TEST_SUCCESS
;
5427 * Test that ensures that buffered set to not trigger problems during io_flush
5429 #define regression_bug_490520_COUNT 200480
5430 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5432 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5433 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5434 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5435 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5436 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5438 memc
->number_of_hosts
= 1;
5440 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5441 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5443 /* First add all of the items.. */
5444 char blob
[3333] = {0};
5445 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5448 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5452 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5453 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5456 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5463 return TEST_SUCCESS
;
5467 static test_return_t
regression_bug_854604(memcached_st
*)
5471 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
5473 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
5475 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
5476 test_compare(buffer
[0], 0);
5478 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
5479 test_true(strlen(buffer
));
5481 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
5482 test_true(strlen(buffer
));
5484 return TEST_SUCCESS
;
5487 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5489 fprintf(stderr
, "Iteration #%u: ", it
);
5491 if (error
== MEMCACHED_ERRNO
)
5493 fprintf(stderr
, "system error %d from %s: %s\n",
5494 errno
, what
, strerror(errno
));
5498 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5499 memcached_strerror(mc
, error
));
5503 #define TEST_CONSTANT_CREATION 200
5505 static test_return_t
regression_bug_(memcached_st
*memc
)
5507 const char *remote_server
;
5510 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5512 return TEST_SKIPPED
;
5515 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5517 memcached_st
* mc
= memcached_create(NULL
);
5518 memcached_return rc
;
5520 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5521 if (rc
!= MEMCACHED_SUCCESS
)
5523 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5526 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5527 if (rc
!= MEMCACHED_SUCCESS
)
5529 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5532 rc
= memcached_server_add(mc
, remote_server
, 0);
5533 if (rc
!= MEMCACHED_SUCCESS
)
5535 memcached_die(mc
, rc
, "memcached_server_add", x
);
5538 const char *set_key
= "akey";
5539 const size_t set_key_len
= strlen(set_key
);
5540 const char *set_value
= "a value";
5541 const size_t set_value_len
= strlen(set_value
);
5543 if (rc
== MEMCACHED_SUCCESS
)
5547 size_t get_value_len
;
5549 uint32_t get_value_flags
;
5551 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5552 &get_value_flags
, &rc
);
5553 if (rc
!= MEMCACHED_SUCCESS
)
5555 memcached_die(mc
, rc
, "memcached_get", x
);
5561 (get_value_len
!= set_value_len
5562 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5564 fprintf(stderr
, "Values don't match?\n");
5565 rc
= MEMCACHED_FAILURE
;
5571 rc
= memcached_set(mc
,
5572 set_key
, set_key_len
,
5573 set_value
, set_value_len
,
5577 if (rc
!= MEMCACHED_SUCCESS
)
5579 memcached_die(mc
, rc
, "memcached_set", x
);
5586 if (rc
!= MEMCACHED_SUCCESS
)
5592 return TEST_SUCCESS
;
5595 /* Clean the server before beginning testing */
5597 {"util_version", true, (test_callback_fn
*)util_version_test
},
5598 {"flush", false, (test_callback_fn
*)flush_test
},
5599 {"init", false, (test_callback_fn
*)init_test
},
5600 {"allocation", false, (test_callback_fn
*)allocation_test
},
5601 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5602 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5603 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5604 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5605 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5606 {"clone_test", false, (test_callback_fn
*)clone_test
},
5607 {"connection_test", false, (test_callback_fn
*)connection_test
},
5608 {"callback_test", false, (test_callback_fn
*)callback_test
},
5609 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5610 {"set", false, (test_callback_fn
*)set_test
},
5611 {"set2", false, (test_callback_fn
*)set_test2
},
5612 {"set3", false, (test_callback_fn
*)set_test3
},
5613 {"dump", true, (test_callback_fn
*)dump_test
},
5614 {"add", true, (test_callback_fn
*)add_test
},
5615 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5616 {"replace", true, (test_callback_fn
*)replace_test
},
5617 {"delete", true, (test_callback_fn
*)delete_test
},
5618 {"get", true, (test_callback_fn
*)get_test
},
5619 {"get2", false, (test_callback_fn
*)get_test2
},
5620 {"get3", false, (test_callback_fn
*)get_test3
},
5621 {"get4", false, (test_callback_fn
*)get_test4
},
5622 {"partial mget", false, (test_callback_fn
*)get_test5
},
5623 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5624 {"increment", false, (test_callback_fn
*)increment_test
},
5625 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5626 {"decrement", false, (test_callback_fn
*)decrement_test
},
5627 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5628 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5629 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5630 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5631 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5632 {"binary_increment_with_prefix", 1, (test_callback_fn
*)binary_increment_with_prefix_test
},
5633 {"quit", false, (test_callback_fn
*)quit_test
},
5634 {"mget", true, (test_callback_fn
*)mget_test
},
5635 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5636 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5637 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5638 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5639 {"mget_end", false, (test_callback_fn
*)mget_end
},
5640 {"get_stats", false, (test_callback_fn
*)get_stats
},
5641 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5642 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5643 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5644 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
5645 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5646 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5647 {"read_through", true, (test_callback_fn
*)read_through
},
5648 {"delete_through", true, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER
},
5649 {"noreply", true, (test_callback_fn
*)noreply_test
},
5650 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5651 {"memcached_pool_st", true, (test_callback_fn
*)connection_pool_test
},
5652 {"memcached_pool_st #2", true, (test_callback_fn
*)connection_pool2_test
},
5654 {"memcached_pool_st #3", true, (test_callback_fn
*)connection_pool3_test
},
5656 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
5657 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
5658 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
5659 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
5660 {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_NOTFOUND
},
5661 {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_SUCCESS
},
5662 {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_by_key_NOTFOUND
},
5663 {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_by_key_SUCCESS
},
5664 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5665 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5669 test_st touch_tests
[] ={
5670 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5671 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5675 test_st behavior_tests
[] ={
5676 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5677 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5678 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5679 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5680 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5681 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5682 {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test
},
5683 {"MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY", false, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY
},
5687 test_st libmemcachedutil_tests
[] ={
5688 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5689 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5690 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5694 test_st basic_tests
[] ={
5695 {"init", true, (test_callback_fn
*)basic_init_test
},
5696 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5697 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5698 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5699 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5700 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5701 {"memcached_return_t", false, (test_callback_fn
*)memcached_return_t_TEST
},
5705 test_st regression_binary_vs_block
[] ={
5706 {"block add", true, (test_callback_fn
*)block_add_regression
},
5707 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
5711 test_st async_tests
[] ={
5712 {"add", true, (test_callback_fn
*)add_wrapper
},
5716 test_st memcached_server_get_last_disconnect_tests
[] ={
5717 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
5718 {0, 0, (test_callback_fn
*)0}
5722 test_st result_tests
[] ={
5723 {"result static", false, (test_callback_fn
*)result_static
},
5724 {"result alloc", false, (test_callback_fn
*)result_alloc
},
5725 {0, 0, (test_callback_fn
*)0}
5728 test_st version_1_2_3
[] ={
5729 {"append", false, (test_callback_fn
*)append_test
},
5730 {"prepend", false, (test_callback_fn
*)prepend_test
},
5731 {"cas", false, (test_callback_fn
*)cas_test
},
5732 {"cas2", false, (test_callback_fn
*)cas2_test
},
5733 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
5734 {0, 0, (test_callback_fn
*)0}
5737 test_st haldenbrand_tests
[] ={
5738 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
5739 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
5740 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
5741 {0, 0, (test_callback_fn
*)0}
5744 test_st user_tests
[] ={
5745 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
5746 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
5747 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
5748 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
5749 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
5750 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
5751 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
5752 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
5753 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
5754 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
5755 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
5756 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
5757 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
5758 #if !defined(__sun) && !defined(__OpenBSD__)
5760 ** It seems to be something weird with the character sets..
5761 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5762 ** guess I need to find out how this is supposed to work.. Perhaps I need
5763 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5764 ** so just disable the code for now...).
5766 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
5768 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
5769 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
5770 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
5771 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
5772 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
5773 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
5774 {0, 0, (test_callback_fn
*)0}
5777 test_st replication_tests
[]= {
5778 {"set", true, (test_callback_fn
*)replication_set_test
},
5779 {"get", false, (test_callback_fn
*)replication_get_test
},
5780 {"mget", false, (test_callback_fn
*)replication_mget_test
},
5781 {"delete", true, (test_callback_fn
*)replication_delete_test
},
5782 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
5783 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
5784 {0, 0, (test_callback_fn
*)0}
5788 * The following test suite is used to verify that we don't introduce
5789 * regression bugs. If you want more information about the bug / test,
5790 * you should look in the bug report at
5791 * http://bugs.launchpad.net/libmemcached
5793 test_st regression_tests
[]= {
5794 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
5795 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
5796 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
5797 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
5798 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
5799 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
5800 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
5801 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
5802 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
5803 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
5804 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
5805 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
5806 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
5807 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
5808 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
5809 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
5810 {"lp:854604", true, (test_callback_fn
*)regression_bug_854604
},
5811 {0, false, (test_callback_fn
*)0}
5814 test_st ketama_compatibility
[]= {
5815 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
5816 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
5817 {0, 0, (test_callback_fn
*)0}
5820 test_st generate_tests
[] ={
5821 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5822 {"generate_data", true, (test_callback_fn
*)generate_data
},
5823 {"get_read", false, (test_callback_fn
*)get_read
},
5824 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
5825 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5826 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
5827 {"generate_data", true, (test_callback_fn
*)generate_data
},
5828 {"mget_read", false, (test_callback_fn
*)mget_read
},
5829 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
5830 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
5831 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
5832 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
5833 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5834 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
5835 {"generate_data", true, (test_callback_fn
*)generate_data
},
5836 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5837 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5838 {0, 0, (test_callback_fn
*)0}
5841 test_st consistent_tests
[] ={
5842 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5843 {"generate_data", true, (test_callback_fn
*)generate_data
},
5844 {"get_read", 0, (test_callback_fn
*)get_read_count
},
5845 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5846 {0, 0, (test_callback_fn
*)0}
5849 test_st consistent_weighted_tests
[] ={
5850 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5851 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
5852 {"get_read", false, (test_callback_fn
*)get_read_count
},
5853 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5854 {0, 0, (test_callback_fn
*)0}
5857 test_st hsieh_availability
[] ={
5858 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
5859 {0, 0, (test_callback_fn
*)0}
5862 test_st murmur_availability
[] ={
5863 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
5864 {0, 0, (test_callback_fn
*)0}
5868 test_st hash_sanity
[] ={
5869 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
5870 {0, 0, (test_callback_fn
*)0}
5874 test_st ketama_auto_eject_hosts
[] ={
5875 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
5876 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
5877 {0, 0, (test_callback_fn
*)0}
5880 test_st hash_tests
[] ={
5881 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
5882 {"md5", false, (test_callback_fn
*)md5_run
},
5883 {"crc", false, (test_callback_fn
*)crc_run
},
5884 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
5885 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
5886 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
5887 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
5888 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
5889 {"murmur", false, (test_callback_fn
*)murmur_run
},
5890 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
5891 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
5892 {0, 0, (test_callback_fn
*)0}
5895 test_st error_conditions
[] ={
5896 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
5897 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
5898 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
5899 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5900 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5901 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
5902 {0, 0, (test_callback_fn
*)0}
5905 test_st parser_tests
[] ={
5906 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
5907 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
5908 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
5909 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
5910 {"hash", false, (test_callback_fn
*)parser_hash_test
},
5911 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
5912 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
5913 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
5914 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
5915 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
5916 {"server", false, (test_callback_fn
*)server_test
},
5917 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
5918 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
5919 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
5920 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
5921 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
5922 {0, 0, (test_callback_fn
*)0}
5925 test_st virtual_bucket_tests
[] ={
5926 {"basic", false, (test_callback_fn
*)virtual_back_map
},
5927 {0, 0, (test_callback_fn
*)0}
5930 test_st memcached_server_add_tests
[] ={
5931 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
5932 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
5933 {0, 0, (test_callback_fn
*)0}
5936 test_st namespace_tests
[] ={
5937 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
5938 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
5939 {0, 0, (test_callback_fn
*)0}
5942 collection_st collection
[] ={
5944 {"hash_sanity", 0, 0, hash_sanity
},
5946 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
5947 {"basic", 0, 0, basic_tests
},
5948 {"hsieh_availability", 0, 0, hsieh_availability
},
5949 {"murmur_availability", 0, 0, murmur_availability
},
5950 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
5951 {"block", 0, 0, tests
},
5952 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
5953 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
5954 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5955 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
5956 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
5957 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
5958 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
5959 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
5960 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
5961 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
5962 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
5963 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
5964 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
5965 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
5966 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
5967 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5968 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
5969 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
5970 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
5971 #ifdef MEMCACHED_ENABLE_DEPRECATED
5972 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
5974 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
5975 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
5976 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
5977 {"specific namespace", 0, 0, namespace_tests
},
5978 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
5979 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
5980 {"result", 0, 0, result_tests
},
5981 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
5982 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
5983 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
5984 {"user written tests", 0, 0, user_tests
},
5985 {"generate", 0, 0, generate_tests
},
5986 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
5987 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
5988 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
5989 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
5990 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
5991 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
5992 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
5994 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
5995 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
5996 {"consistent_not", 0, 0, consistent_tests
},
5997 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
5998 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
5999 {"ketama_compat", 0, 0, ketama_compatibility
},
6000 {"test_hashes", 0, 0, hash_tests
},
6001 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6002 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6003 {"regression", 0, 0, regression_tests
},
6004 {"behaviors", 0, 0, behavior_tests
},
6005 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6006 {"error_conditions", 0, 0, error_conditions
},
6007 {"parser", 0, 0, parser_tests
},
6008 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6009 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6010 {"touch", 0, 0, touch_tests
},
6014 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
6016 #include "tests/libmemcached_world.h"
6018 void get_world(Framework
*world
)
6020 world
->collections
= collection
;
6022 world
->_create
= (test_callback_create_fn
*)world_create
;
6023 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6025 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6026 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6027 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6028 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6029 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6031 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6032 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6034 world
->set_runner(&defualt_libmemcached_runner
);
6036 world
->set_socket();