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(37, 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
= NULL
;
2123 while ((result
= memcached_fetch_result(memc
, result
, &rc
)))
2125 test_compare(MEMCACHED_SUCCESS
, rc
);
2128 memcached_result_free(result
);
2130 return TEST_SUCCESS
;
2133 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
)
2135 memcached_return_t rc
;
2136 return fetch_all_results(memc
, keys_returned
, rc
);
2139 /* Test case provided by Cal Haldenbrand */
2140 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2141 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2142 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2144 /* We just keep looking at the same values over and over */
2147 test_compare(MEMCACHED_SUCCESS
,
2148 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2149 test_compare(MEMCACHED_SUCCESS
,
2150 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2154 unsigned long long total
= 0;
2155 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2157 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2158 char randomstuff
[6 * 1024];
2159 memset(randomstuff
, 0, 6 * 1024);
2160 test_true(size
< 6 * 1024); /* Being safe here */
2162 for (uint32_t j
= 0 ; j
< size
;j
++)
2164 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2168 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2169 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2170 test_compare(MEMCACHED_SUCCESS
,
2171 memcached_set(memc
, key
, key_length
,
2172 randomstuff
, strlen(randomstuff
),
2173 time_t(0), HALDENBRAND_FLAG_KEY
));
2175 test_true(total
> HALDENBRAND_KEY_COUNT
);
2177 return TEST_SUCCESS
;
2180 /* Test case provided by Cal Haldenbrand */
2181 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2183 test_compare(MEMCACHED_SUCCESS
,
2184 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2186 test_compare(MEMCACHED_SUCCESS
,
2187 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2190 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576));
2191 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576));
2192 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2193 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2195 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2198 size_t total_value_length
= 0;
2199 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2204 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2205 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2207 memcached_return_t rc
;
2208 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2209 if (memcached_failed(rc
))
2211 if (rc
== MEMCACHED_NOTFOUND
)
2222 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2225 total_value_length
+= val_len
;
2230 return TEST_SUCCESS
;
2233 /* Do a large mget() over all the keys we think exist */
2234 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2236 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2237 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2240 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576);
2241 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576);
2242 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2243 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2246 std::vector
<size_t> key_lengths
;
2247 key_lengths
.resize(HALDENBRAND_KEY_COUNT
);
2248 std::vector
<char *> keys
;
2249 keys
.resize(key_lengths
.size());
2250 for (uint32_t x
= 0; x
< key_lengths
.size(); x
++)
2252 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2253 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2254 test_true(key_length
> 0 and key_length
< MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1);
2255 keys
[x
]= strdup(key
);
2256 key_lengths
[x
]= key_length
;
2259 test_compare(MEMCACHED_SUCCESS
,
2260 memcached_mget(memc
, &keys
[0], &key_lengths
[0], key_lengths
.size()));
2262 unsigned int keys_returned
;
2263 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
));
2264 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2266 for (std::vector
<char *>::iterator iter
= keys
.begin();
2273 return TEST_SUCCESS
;
2276 /* Make sure we behave properly if server list has no values */
2277 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2279 const char *keys
[]= {"fudge", "son", "food"};
2280 size_t key_length
[]= {5, 3, 4};
2282 /* Here we free everything before running a bunch of mget tests */
2283 memcached_servers_reset(memc
);
2286 /* We need to empty the server before continueing test */
2287 test_compare(MEMCACHED_NO_SERVERS
,
2288 memcached_flush(memc
, 0));
2290 test_compare(MEMCACHED_NO_SERVERS
,
2291 memcached_mget(memc
, keys
, key_length
, 3));
2294 unsigned int keys_returned
;
2295 memcached_return_t rc
;
2296 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2297 test_compare(MEMCACHED_NOTFOUND
, rc
);
2298 test_zero(keys_returned
);
2301 for (uint32_t x
= 0; x
< 3; x
++)
2303 test_compare(MEMCACHED_NO_SERVERS
,
2304 memcached_set(memc
, keys
[x
], key_length
[x
],
2305 keys
[x
], key_length
[x
],
2306 (time_t)50, (uint32_t)9));
2309 test_compare(MEMCACHED_NO_SERVERS
,
2310 memcached_mget(memc
, keys
, key_length
, 3));
2314 char return_key
[MEMCACHED_MAX_KEY
];
2315 memcached_return_t rc
;
2316 size_t return_key_length
;
2317 size_t return_value_length
;
2320 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2321 &return_value_length
, &flags
, &rc
)))
2323 test_true(return_value
);
2324 test_compare(MEMCACHED_SUCCESS
, rc
);
2325 test_true(return_key_length
== return_value_length
);
2326 test_memcmp(return_value
, return_key
, return_value_length
);
2332 return TEST_SUCCESS
;
2335 #define VALUE_SIZE_BUG5 1048064
2336 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2338 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2339 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2341 size_t value_length
;
2343 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2345 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2347 insert_data
[x
]= (signed char)rand();
2350 test_compare(MEMCACHED_SUCCESS
,
2351 memcached_flush(memc
, 0));
2353 memcached_return_t rc
;
2354 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2355 test_compare(MEMCACHED_SUCCESS
,
2356 memcached_mget(memc
, keys
, key_length
, 4));
2359 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2360 test_compare(MEMCACHED_NOTFOUND
, rc
);
2363 for (uint32_t x
= 0; x
< 4; x
++)
2365 test_compare(MEMCACHED_SUCCESS
,
2366 memcached_set(memc
, keys
[x
], key_length
[x
],
2367 insert_data
, VALUE_SIZE_BUG5
,
2368 (time_t)0, (uint32_t)0));
2371 for (uint32_t x
= 0; x
< 10; x
++)
2373 value
= memcached_get(memc
, keys
[0], key_length
[0],
2374 &value_length
, &flags
, &rc
);
2375 test_compare(rc
, MEMCACHED_SUCCESS
);
2379 test_compare(MEMCACHED_SUCCESS
,
2380 memcached_mget(memc
, keys
, key_length
, 4));
2382 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2383 test_compare(4U, count
);
2385 delete [] insert_data
;
2387 return TEST_SUCCESS
;
2390 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2392 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2393 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2394 char return_key
[MEMCACHED_MAX_KEY
];
2395 size_t return_key_length
;
2397 size_t value_length
;
2399 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2401 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2403 insert_data
[x
]= (signed char)rand();
2406 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2408 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2410 // We will now confirm that memcached_mget() returns success, but we will
2411 // then check to make sure that no actual keys are returned.
2412 test_compare(MEMCACHED_SUCCESS
,
2413 memcached_mget(memc
, keys
, key_length
, 4));
2415 memcached_return_t rc
;
2417 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2418 &value_length
, &flags
, &rc
)))
2423 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2425 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2427 test_compare(MEMCACHED_SUCCESS
,
2428 memcached_set(memc
, keys
[x
], key_length
[x
],
2429 insert_data
, VALUE_SIZE_BUG5
,
2430 (time_t)0, (uint32_t)0));
2432 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2434 for (uint32_t x
= 0; x
< 2; x
++)
2436 value
= memcached_get(memc
, keys
[0], key_length
[0],
2437 &value_length
, &flags
, &rc
);
2441 test_compare(MEMCACHED_SUCCESS
,
2442 memcached_mget(memc
, keys
, key_length
, 4));
2443 /* We test for purge of partial complete fetches */
2444 for (count
= 3; count
; count
--)
2446 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2447 &value_length
, &flags
, &rc
);
2448 test_compare(MEMCACHED_SUCCESS
, rc
);
2449 test_memcmp(value
, insert_data
, value_length
);
2450 test_true(value_length
);
2454 delete [] insert_data
;
2456 return TEST_SUCCESS
;
2459 static test_return_t
user_supplied_bug8(memcached_st
*)
2461 memcached_return_t rc
;
2463 memcached_st
*memc_clone
;
2465 memcached_server_st
*servers
;
2466 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";
2468 servers
= memcached_servers_parse(server_list
);
2471 mine
= memcached_create(NULL
);
2472 rc
= memcached_server_push(mine
, servers
);
2473 test_compare(MEMCACHED_SUCCESS
, rc
);
2474 memcached_server_list_free(servers
);
2477 memc_clone
= memcached_clone(NULL
, mine
);
2479 memcached_quit(mine
);
2480 memcached_quit(memc_clone
);
2483 memcached_free(mine
);
2484 memcached_free(memc_clone
);
2486 return TEST_SUCCESS
;
2489 /* Test flag store/retrieve */
2490 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2492 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2493 test_true(insert_data
);
2495 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2497 insert_data
[x
]= (signed char)rand();
2500 memcached_flush(memc
, 0);
2502 const char *keys
= "036790384900";
2503 size_t key_length
= strlen(keys
);
2504 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2505 insert_data
, VALUE_SIZE_BUG5
,
2507 memcached_last_error_message(memc
));
2509 memcached_return_t rc
;
2510 size_t value_length
;
2512 char *value
= memcached_get(memc
, keys
, key_length
,
2513 &value_length
, &flags
, &rc
);
2514 test_compare(245U, flags
);
2518 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2520 char return_key
[MEMCACHED_MAX_KEY
];
2521 size_t return_key_length
;
2523 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2524 &value_length
, &flags
, &rc
);
2525 test_compare(uint32_t(245), flags
);
2528 delete [] insert_data
;
2531 return TEST_SUCCESS
;
2534 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2536 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2537 size_t key_length
[3];
2541 char return_key
[MEMCACHED_MAX_KEY
];
2542 size_t return_key_length
;
2544 size_t return_value_length
;
2547 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2548 key_length
[1]= strlen("fudge&*@#");
2549 key_length
[2]= strlen("for^#@&$not");
2552 for (unsigned int x
= 0; x
< 3; x
++)
2554 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2555 keys
[x
], key_length
[x
],
2556 (time_t)50, (uint32_t)9);
2557 test_compare(MEMCACHED_SUCCESS
, rc
);
2560 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2561 test_compare(MEMCACHED_SUCCESS
, rc
);
2563 /* We need to empty the server before continueing test */
2564 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2565 &return_value_length
, &flags
, &rc
)) != NULL
)
2567 test_true(return_value
);
2571 test_compare(3U, count
);
2573 return TEST_SUCCESS
;
2576 /* We are testing with aggressive timeout to get failures */
2577 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2579 size_t value_length
= 512;
2580 unsigned int set
= 1;
2581 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2583 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2584 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2585 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2587 std::vector
<char> value
;
2588 value
.reserve(value_length
);
2589 for (uint32_t x
= 0; x
< value_length
; x
++)
2591 value
.push_back(char(x
% 127));
2594 for (unsigned int x
= 1; x
<= 100000; ++x
)
2596 memcached_return_t rc
= memcached_set(mclone
,
2597 test_literal_param("foo"),
2598 &value
[0], value
.size(),
2601 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2602 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2603 memcached_strerror(NULL
, rc
));
2605 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2611 memcached_free(mclone
);
2613 return TEST_SUCCESS
;
2617 We are looking failures in the async protocol
2619 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2621 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2623 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2624 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2625 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2627 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2630 std::vector
<char> value
;
2632 for (unsigned int x
= 0; x
< 512; x
++)
2634 value
.push_back(char(x
% 127));
2637 for (unsigned int x
= 1; x
<= 100000; ++x
)
2639 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2643 memcached_free(mclone
);
2645 return TEST_SUCCESS
;
2649 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2651 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2653 memcached_return_t rc
;
2655 size_t value_length
;
2657 uint64_t number_value
;
2659 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2660 &value_length
, &flags
, &rc
);
2662 test_compare(MEMCACHED_NOTFOUND
, rc
);
2664 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2667 /* The binary protocol will set the key if it doesn't exist */
2668 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2670 test_compare(MEMCACHED_SUCCESS
, rc
);
2674 test_compare(MEMCACHED_NOTFOUND
, rc
);
2677 test_compare(MEMCACHED_SUCCESS
,
2678 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2680 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2684 test_compare(MEMCACHED_SUCCESS
,
2685 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2686 test_compare(2UL, number_value
);
2688 return TEST_SUCCESS
;
2692 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2693 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2695 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2697 char key
[] = "key34567890";
2698 memcached_return_t rc
;
2699 size_t overflowSize
;
2701 char commandFirst
[]= "set key34567890 0 0 ";
2702 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2703 size_t commandLength
;
2706 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2708 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2710 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2712 char *overflow
= new (std::nothrow
) char[testSize
];
2713 test_true(overflow
);
2715 memset(overflow
, 'x', testSize
);
2716 rc
= memcached_set(memc
, key
, strlen(key
),
2717 overflow
, testSize
, 0, 0);
2718 test_compare(MEMCACHED_SUCCESS
, rc
);
2722 return TEST_SUCCESS
;
2727 Test values of many different sizes
2728 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2729 set key34567890 0 0 8169 \r\n
2730 is sent followed by buffer of size 8169, followed by 8169
2732 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2734 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2736 std::vector
<char> value
;
2737 value
.reserve(18000);
2738 for (size_t x
= 0; x
< 18000; x
++)
2740 value
.push_back((char) (x
% 127));
2743 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2745 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2746 &value
[0], current_length
,
2747 (time_t)0, (uint32_t)0);
2748 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2750 size_t string_length
;
2752 char *string
= memcached_get(memc
, test_literal_param("foo"),
2753 &string_length
, &flags
, &rc
);
2755 test_compare(MEMCACHED_SUCCESS
, rc
);
2756 test_compare(string_length
, current_length
);
2757 test_memcmp(string
, &value
[0], string_length
);
2762 return TEST_SUCCESS
;
2766 Look for zero length value problems
2768 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2770 for (uint32_t x
= 0; x
< 2; x
++)
2772 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2774 (time_t)0, (uint32_t)0);
2776 test_compare(MEMCACHED_SUCCESS
, rc
);
2780 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2781 &length
, &flags
, &rc
);
2783 test_compare(MEMCACHED_SUCCESS
, rc
);
2788 value
= memcached_get(memc
, test_literal_param("mykey"),
2789 &length
, &flags
, &rc
);
2791 test_compare(MEMCACHED_SUCCESS
, rc
);
2792 test_true(value
== NULL
);
2797 return TEST_SUCCESS
;
2800 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2801 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2803 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2805 (time_t)0, UINT32_MAX
),
2806 memcached_last_error_message(memc
));
2811 memcached_return_t rc
;
2812 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2813 &length
, &flags
, &rc
);
2815 test_compare(MEMCACHED_SUCCESS
, rc
);
2818 test_compare(flags
, UINT32_MAX
);
2820 return TEST_SUCCESS
;
2823 #if !defined(__sun) && !defined(__OpenBSD__)
2824 /* Check the validity of chinese key*/
2825 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2827 const char *key
= "豆瓣";
2828 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2829 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2830 value
, strlen(value
),
2833 test_compare(MEMCACHED_SUCCESS
, rc
);
2837 char *value2
= memcached_get(memc
, key
, strlen(key
),
2838 &length
, &flags
, &rc
);
2840 test_true(length
==strlen(value
));
2841 test_compare(MEMCACHED_SUCCESS
, rc
);
2842 test_memcmp(value
, value2
, length
);
2845 return TEST_SUCCESS
;
2853 static test_return_t
user_supplied_bug19(memcached_st
*)
2855 memcached_return_t res
;
2857 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2859 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2862 memcached_free(memc
);
2864 return TEST_SUCCESS
;
2867 /* CAS test from Andei */
2868 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2870 const char *key
= "abc";
2871 size_t key_len
= strlen("abc");
2873 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2875 test_compare(MEMCACHED_SUCCESS
,
2877 test_literal_param("abc"),
2878 test_literal_param("foobar"),
2879 (time_t)0, (uint32_t)0));
2881 test_compare(MEMCACHED_SUCCESS
,
2882 memcached_mget(memc
, &key
, &key_len
, 1));
2884 memcached_result_st result_obj
;
2885 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2888 memcached_result_create(memc
, &result_obj
);
2889 memcached_return_t status
;
2890 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2893 test_compare(MEMCACHED_SUCCESS
, status
);
2895 memcached_result_free(result
);
2897 return TEST_SUCCESS
;
2900 /* Large mget() of missing keys with binary proto
2902 * If many binary quiet commands (such as getq's in an mget) fill the output
2903 * buffer and the server chooses not to respond, memcached_flush hangs. See
2904 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2907 /* sighandler_t function that always asserts false */
2908 static void fail(int)
2914 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2919 return TEST_SKIPPED
;
2921 void (*oldalarm
)(int);
2923 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2924 test_true(memc_clone
);
2926 /* only binproto uses getq for mget */
2927 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2929 /* empty the cache to ensure misses (hence non-responses) */
2930 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2932 std::vector
<size_t> key_lengths
;
2933 key_lengths
.resize(key_count
);
2934 std::vector
<char *> keys
;
2935 keys
.resize(key_lengths
.size());
2936 for (unsigned int x
= 0; x
< key_lengths
.size(); x
++)
2938 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2939 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2940 test_true(key_length
> 0 and key_length
< MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1);
2941 keys
[x
]= strdup(key
);
2942 key_lengths
[x
]= key_length
;
2945 oldalarm
= signal(SIGALRM
, fail
);
2948 test_compare_got(MEMCACHED_SUCCESS
,
2949 memcached_mget(memc_clone
, &keys
[0], &key_lengths
[0], key_count
), memcached_last_error_message(memc_clone
));
2952 signal(SIGALRM
, oldalarm
);
2954 memcached_return_t rc
;
2956 char return_key
[MEMCACHED_MAX_KEY
];
2957 size_t return_key_length
;
2959 size_t return_value_length
;
2960 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2961 &return_value_length
, &flags
, &rc
)))
2963 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2965 test_compare(MEMCACHED_NOTFOUND
, rc
);
2966 test_zero(return_value_length
);
2967 test_zero(return_key_length
);
2968 test_false(return_key
[0]);
2969 test_false(return_value
);
2971 for (std::vector
<char *>::iterator iter
= keys
.begin();
2978 memcached_free(memc_clone
);
2980 return TEST_SUCCESS
;
2984 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
2986 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2988 /* should work as of r580 */
2989 test_compare(TEST_SUCCESS
,
2990 _user_supplied_bug21(memc
, 10));
2992 /* should fail as of r580 */
2993 test_compare(TEST_SUCCESS
,
2994 _user_supplied_bug21(memc
, 1000));
2996 return TEST_SUCCESS
;
2999 static test_return_t
output_ketama_weighted_keys(memcached_st
*)
3001 memcached_st
*memc
= memcached_create(NULL
);
3005 test_compare(MEMCACHED_SUCCESS
,
3006 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
3008 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3009 test_compare(value
, uint64_t(1));
3011 test_compare(MEMCACHED_SUCCESS
,
3012 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3014 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3015 test_true(value
== MEMCACHED_HASH_MD5
);
3018 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3020 memcached_server_st
*server_pool
;
3021 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");
3022 memcached_server_push(memc
, server_pool
);
3024 // @todo this needs to be refactored to actually test something.
3027 if ((fp
= fopen("ketama_keys.txt", "w")))
3031 printf("cannot write to file ketama_keys.txt");
3032 return TEST_FAILURE
;
3035 for (int x
= 0; x
< 10000; x
++)
3038 snprintf(key
, sizeof(key
), "%d", x
);
3040 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3041 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3042 in_port_t port
= memc
->hosts
[server_idx
].port
;
3043 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3044 memcached_server_instance_st instance
=
3045 memcached_server_instance_by_position(memc
, host_index
);
3049 memcached_server_list_free(server_pool
);
3050 memcached_free(memc
);
3052 return TEST_SUCCESS
;
3056 static test_return_t
result_static(memcached_st
*memc
)
3058 memcached_result_st result
;
3059 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3060 test_false(result
.options
.is_allocated
);
3061 test_true(memcached_is_initialized(&result
));
3062 test_true(result_ptr
);
3063 test_true(result_ptr
== &result
);
3065 memcached_result_free(&result
);
3067 test_false(result
.options
.is_allocated
);
3068 test_false(memcached_is_initialized(&result
));
3070 return TEST_SUCCESS
;
3073 static test_return_t
result_alloc(memcached_st
*memc
)
3075 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3076 test_true(result_ptr
);
3077 test_true(result_ptr
->options
.is_allocated
);
3078 test_true(memcached_is_initialized(result_ptr
));
3079 memcached_result_free(result_ptr
);
3081 return TEST_SUCCESS
;
3084 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3087 pairs_free(global_pairs
);
3089 return TEST_SUCCESS
;
3092 static test_return_t
generate_pairs(memcached_st
*)
3094 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3095 global_count
= GLOBAL_COUNT
;
3097 for (size_t x
= 0; x
< global_count
; x
++)
3099 global_keys
[x
]= global_pairs
[x
].key
;
3100 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3103 return TEST_SUCCESS
;
3106 static test_return_t
generate_large_pairs(memcached_st
*)
3108 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3109 global_count
= GLOBAL2_COUNT
;
3111 for (size_t x
= 0; x
< global_count
; x
++)
3113 global_keys
[x
]= global_pairs
[x
].key
;
3114 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3117 return TEST_SUCCESS
;
3120 static test_return_t
generate_data(memcached_st
*memc
)
3122 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3124 test_compare_warn_hint(global_count
, check_execute
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3126 return TEST_SUCCESS
;
3129 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3131 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3133 test_compare(check_execute
, global_count
);
3135 // @todo hosts used size stats
3136 memcached_return_t rc
;
3137 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3140 for (uint32_t host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3142 /* This test was changes so that "make test" would work properlly */
3145 memcached_server_instance_st instance
=
3146 memcached_server_instance_by_position(memc
, host_index
);
3148 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3150 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3153 memcached_stat_free(NULL
, stat_p
);
3155 return TEST_SUCCESS
;
3157 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3159 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3160 generate_data(memc
);
3162 return TEST_SUCCESS
;
3165 static test_return_t
get_read_count(memcached_st
*memc
)
3167 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3168 test_true(memc_clone
);
3170 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3174 size_t return_value_length
;
3178 for (size_t x
= count
= 0; x
< global_count
; x
++)
3180 memcached_return_t rc
;
3181 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3182 &return_value_length
, &flags
, &rc
);
3183 if (rc
== MEMCACHED_SUCCESS
)
3194 memcached_free(memc_clone
);
3196 return TEST_SUCCESS
;
3199 static test_return_t
get_read(memcached_st
*memc
)
3201 size_t keys_returned
= 0;
3202 for (size_t x
= 0; x
< global_count
; x
++)
3204 size_t return_value_length
;
3206 memcached_return_t rc
;
3207 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3208 &return_value_length
, &flags
, &rc
);
3210 test_true(return_value);
3211 test_compare(MEMCACHED_SUCCESS, rc);
3213 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3219 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3221 return TEST_SUCCESS
;
3224 static test_return_t
mget_read(memcached_st
*memc
)
3227 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3229 test_compare(MEMCACHED_SUCCESS
,
3230 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3232 // Go fetch the keys and test to see if all of them were returned
3234 unsigned int keys_returned
;
3235 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
));
3236 test_true(keys_returned
> 0);
3237 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3240 return TEST_SUCCESS
;
3243 static test_return_t
mget_read_result(memcached_st
*memc
)
3246 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3248 test_compare(MEMCACHED_SUCCESS
,
3249 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3251 /* Turn this into a help function */
3253 memcached_result_st results_obj
;
3254 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3257 memcached_return_t rc
;
3258 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3260 if (rc
== MEMCACHED_IN_PROGRESS
)
3266 test_compare(MEMCACHED_SUCCESS
, rc
);
3268 test_compare(MEMCACHED_END
, rc
);
3270 memcached_result_free(&results_obj
);
3273 return TEST_SUCCESS
;
3276 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3279 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3281 test_compare(MEMCACHED_SUCCESS
,
3282 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3284 memcached_result_st
*results
= NULL
;
3285 memcached_return_t rc
;
3286 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3289 test_compare(MEMCACHED_SUCCESS
, rc
);
3291 test_compare(MEMCACHED_END
, rc
);
3293 memcached_result_free(results
);
3296 return TEST_SUCCESS
;
3299 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3302 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3304 test_compare(MEMCACHED_SUCCESS
,
3305 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3307 // We will scan for just one key
3309 memcached_result_st results_obj
;
3310 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3312 memcached_return_t rc
;
3313 results
= memcached_fetch_result(memc
, results
, &rc
);
3315 test_compare(MEMCACHED_SUCCESS
, rc
);
3317 memcached_result_free(&results_obj
);
3320 // We already have a read happening, lets start up another one.
3321 test_compare(MEMCACHED_SUCCESS
,
3322 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3324 memcached_result_st results_obj
;
3325 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3327 test_false(memcached_is_allocated(results
));
3329 memcached_return_t rc
;
3330 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3333 test_compare(MEMCACHED_SUCCESS
, rc
);
3335 test_compare(MEMCACHED_END
, rc
);
3337 memcached_result_free(&results_obj
);
3340 return TEST_SUCCESS
;
3343 static test_return_t
mget_read_function(memcached_st
*memc
)
3345 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3347 test_compare(MEMCACHED_SUCCESS
,
3348 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3350 memcached_execute_fn callbacks
[]= { &callback_counter
};
3352 test_compare(MEMCACHED_SUCCESS
,
3353 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3355 return TEST_SUCCESS
;
3358 static test_return_t
delete_generate(memcached_st
*memc
)
3361 for (size_t x
= 0; x
< global_count
; x
++)
3363 if (memcached_success(memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0)))
3368 test_compare_warn_hint(global_count
, total
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3370 return TEST_SUCCESS
;
3373 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3375 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3378 for (size_t x
= 0; x
< global_count
; x
++)
3380 if (memcached_success(memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0)))
3385 test_compare_warn_hint(global_count
, total
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3387 return TEST_SUCCESS
;
3390 static test_return_t
add_host_test1(memcached_st
*memc
)
3392 memcached_return_t rc
;
3393 char servername
[]= "0.example.com";
3395 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3397 test_compare(1U, memcached_server_list_count(servers
));
3399 for (uint32_t x
= 2; x
< 20; x
++)
3401 char buffer
[SMALL_STRING_LEN
];
3403 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3404 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3406 test_compare(MEMCACHED_SUCCESS
, rc
);
3407 test_compare(x
, memcached_server_list_count(servers
));
3410 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3411 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3413 memcached_server_list_free(servers
);
3415 return TEST_SUCCESS
;
3418 static test_return_t
pre_nonblock(memcached_st
*memc
)
3420 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3422 return TEST_SUCCESS
;
3425 static test_return_t
pre_cork(memcached_st
*memc
)
3428 return TEST_SKIPPED
;
3431 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3432 return TEST_SUCCESS
;
3434 return TEST_SKIPPED
;
3437 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3440 return TEST_SKIPPED
;
3442 test_return_t test_rc
;
3443 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3446 return pre_nonblock(memc
);
3449 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3451 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3452 test_true(memc_clone
);
3454 // The memcached_version needs to be done on a clone, because the server
3455 // will not toggle protocol on an connection.
3456 memcached_version(memc_clone
);
3458 memcached_return_t rc
= MEMCACHED_FAILURE
;
3459 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3461 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3462 test_compare(MEMCACHED_SUCCESS
,
3463 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3464 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3468 memcached_free(memc_clone
);
3469 return TEST_SKIPPED
;
3472 memcached_free(memc_clone
);
3474 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3477 static test_return_t
pre_murmur(memcached_st
*memc
)
3479 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3480 return TEST_SUCCESS
;
3483 static test_return_t
pre_jenkins(memcached_st
*memc
)
3485 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3487 return TEST_SKIPPED
;
3491 static test_return_t
pre_md5(memcached_st
*memc
)
3493 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3495 return TEST_SUCCESS
;
3498 static test_return_t
pre_crc(memcached_st
*memc
)
3500 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3502 return TEST_SUCCESS
;
3505 static test_return_t
pre_hsieh(memcached_st
*memc
)
3507 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
));
3508 return TEST_SUCCESS
;
3511 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3513 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3515 return TEST_SUCCESS
;
3518 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3520 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
));
3522 return TEST_SUCCESS
;
3525 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3527 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3529 return TEST_SUCCESS
;
3532 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3534 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3536 return TEST_SUCCESS
;
3539 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3541 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3542 test_compare(MEMCACHED_SUCCESS
, rc
);
3544 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3545 test_compare(value
, uint64_t(1));
3547 return TEST_SUCCESS
;
3550 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3552 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3553 test_compare(MEMCACHED_SUCCESS
, rc
);
3555 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3556 test_compare(value
, uint64_t(1));
3558 test_compare(MEMCACHED_SUCCESS
,
3559 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3561 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3562 test_compare(MEMCACHED_HASH_MD5
, memcached_hash_t(value
));
3564 return TEST_SUCCESS
;
3567 static test_return_t
pre_replication(memcached_st
*memc
)
3569 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3572 * Make sure that we store the item on all servers
3573 * (master + replicas == number of servers)
3575 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3576 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3578 return TEST_SUCCESS
;
3582 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3584 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3586 return pre_nonblock(memc
);
3590 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3594 #ifdef HARD_MALLOC_TESTS
3595 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3603 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3607 #ifdef HARD_MALLOC_TESTS
3608 void *ret
= malloc(size
+ 8);
3611 ret
= (void*)((caddr_t
)ret
+ 8);
3614 void *ret
= malloc(size
);
3619 memset(ret
, 0xff, size
);
3626 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3628 #ifdef HARD_MALLOC_TESTS
3629 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3630 void *nmem
= realloc(real_ptr
, size
+ 8);
3635 ret
= (void*)((caddr_t
)nmem
+ 8);
3641 return realloc(mem
, size
);
3646 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3648 #ifdef HARD_MALLOC_TESTS
3649 void *mem
= my_malloc(ptr
, nelem
* size
);
3652 memset(mem
, 0, nelem
* size
);
3658 return calloc(nelem
, size
);
3662 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3664 memcached_return_t rc
;
3665 const char *key
= "mine";
3668 /* Make sure be default none exists */
3669 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3671 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3673 /* Test a clean set */
3674 test_compare(MEMCACHED_SUCCESS
,
3675 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3677 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3679 test_memcmp(value
, key
, 4);
3680 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3682 /* Test that we can turn it off */
3683 test_compare(MEMCACHED_SUCCESS
,
3684 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3686 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3688 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3690 /* Now setup for main test */
3691 test_compare(MEMCACHED_SUCCESS
,
3692 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3694 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3696 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3697 test_memcmp(value
, key
, 4);
3699 /* Set to Zero, and then Set to something too large */
3702 memset(long_key
, 0, 255);
3704 test_compare(MEMCACHED_SUCCESS
,
3705 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3707 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3709 test_compare(MEMCACHED_SUCCESS
, rc
);
3711 /* Test a long key for failure */
3712 /* TODO, extend test to determine based on setting, what result should be */
3713 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3714 test_compare(MEMCACHED_SUCCESS
,
3715 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3717 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3718 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3719 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3720 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3722 /* Test for a bad prefix, but with a short key */
3723 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3724 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3726 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3727 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3730 return TEST_SUCCESS
;
3733 static test_return_t
set_namespace(memcached_st
*memc
)
3735 memcached_return_t rc
;
3736 const char *key
= "mine";
3739 // Make sure we default to a null namespace
3740 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3742 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3744 /* Test a clean set */
3745 test_compare(MEMCACHED_SUCCESS
,
3746 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3748 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3750 test_memcmp(value
, key
, 4);
3751 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3753 return TEST_SUCCESS
;
3756 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3758 test_return_if(pre_binary(memc
));
3759 test_return_if(set_namespace(memc
));
3761 return TEST_SUCCESS
;
3764 #ifdef MEMCACHED_ENABLE_DEPRECATED
3765 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3767 void *test_ptr
= NULL
;
3770 memcached_malloc_fn malloc_cb
=
3771 (memcached_malloc_fn
)my_malloc
;
3772 cb_ptr
= *(void **)&malloc_cb
;
3773 memcached_return_t rc
;
3775 test_compare(MEMCACHED_SUCCESS
,
3776 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3777 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3778 test_compare(MEMCACHED_SUCCESS
, rc
);
3779 test_true(test_ptr
== cb_ptr
);
3783 memcached_realloc_fn realloc_cb
=
3784 (memcached_realloc_fn
)my_realloc
;
3785 cb_ptr
= *(void **)&realloc_cb
;
3786 memcached_return_t rc
;
3788 test_compare(MEMCACHED_SUCCESS
,
3789 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3790 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3791 test_compare(MEMCACHED_SUCCESS
, rc
);
3792 test_true(test_ptr
== cb_ptr
);
3796 memcached_free_fn free_cb
=
3797 (memcached_free_fn
)my_free
;
3798 cb_ptr
= *(void **)&free_cb
;
3799 memcached_return_t rc
;
3801 test_compare(MEMCACHED_SUCCESS
,
3802 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3803 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3804 test_compare(MEMCACHED_SUCCESS
, rc
);
3805 test_true(test_ptr
== cb_ptr
);
3808 return TEST_SUCCESS
;
3813 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3815 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3816 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3817 my_realloc
, my_calloc
, NULL
));
3819 test_compare(MEMCACHED_SUCCESS
,
3820 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3821 my_realloc
, my_calloc
, NULL
));
3823 memcached_malloc_fn mem_malloc
;
3824 memcached_free_fn mem_free
;
3825 memcached_realloc_fn mem_realloc
;
3826 memcached_calloc_fn mem_calloc
;
3827 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3828 &mem_realloc
, &mem_calloc
);
3830 test_true(mem_malloc
== my_malloc
);
3831 test_true(mem_realloc
== my_realloc
);
3832 test_true(mem_calloc
== my_calloc
);
3833 test_true(mem_free
== my_free
);
3835 return TEST_SUCCESS
;
3838 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3841 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3842 memcached_hash_t hash
;
3843 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3844 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3847 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3848 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3850 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3852 if (hash
!= MEMCACHED_HASH_CRC
)
3853 return TEST_SKIPPED
;
3855 return TEST_SUCCESS
;
3858 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3861 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3862 memcached_hash_t hash
;
3863 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3864 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3869 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3870 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3872 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3874 if (hash
!= MEMCACHED_HASH_HSIEH
)
3875 return TEST_SKIPPED
;
3878 return TEST_SUCCESS
;
3881 static test_return_t
enable_cas(memcached_st
*memc
)
3883 unsigned int set
= 1;
3885 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3887 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3889 return TEST_SUCCESS
;
3892 return TEST_SKIPPED
;
3895 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3897 memcached_version(memc
);
3899 memcached_server_instance_st instance
=
3900 memcached_server_instance_by_position(memc
, 0);
3902 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3903 or instance
->minor_version
> 2)
3905 return TEST_SUCCESS
;
3908 return TEST_SKIPPED
;
3911 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3915 memcached_servers_reset(memc
);
3916 const char *socket_file
= default_socket();
3918 test_skip(0, stat(socket_file
, &buf
));
3920 test_compare(MEMCACHED_SUCCESS
,
3921 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
3923 return TEST_SUCCESS
;
3926 static test_return_t
pre_nodelay(memcached_st
*memc
)
3928 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3929 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3931 return TEST_SUCCESS
;
3934 static test_return_t
pre_settimer(memcached_st
*memc
)
3936 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3937 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3939 return TEST_SUCCESS
;
3942 static test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3944 const uint64_t timeout
= 100; // Not using, just checking that it sets
3946 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3948 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3950 return TEST_SUCCESS
;
3953 static test_return_t
noreply_test(memcached_st
*memc
)
3955 test_compare(MEMCACHED_SUCCESS
,
3956 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3957 test_compare(MEMCACHED_SUCCESS
,
3958 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3959 test_compare(MEMCACHED_SUCCESS
,
3960 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3961 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3962 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3963 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3965 memcached_return_t ret
;
3966 for (int count
= 0; count
< 5; ++count
)
3968 for (size_t x
= 0; x
< 100; ++x
)
3971 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3972 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3974 size_t len
= (size_t)check_length
;
3979 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3982 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3985 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3988 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3991 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3997 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, ret
));
4001 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4002 ** API and is _ONLY_ done this way to verify that the library works the
4003 ** way it is supposed to do!!!!
4006 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4008 memcached_server_instance_st instance
=
4009 memcached_server_instance_by_position(memc
, x
);
4010 no_msg
+=(int)(instance
->cursor_active
);
4013 test_true(no_msg
== 0);
4014 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4017 ** Now validate that all items was set properly!
4019 for (size_t x
= 0; x
< 100; ++x
)
4023 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4025 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4027 size_t len
= (size_t)check_length
;
4030 char* value
=memcached_get(memc
, key
, strlen(key
),
4031 &length
, &flags
, &ret
);
4032 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
4035 case 0: /* FALLTHROUGH */
4036 case 1: /* FALLTHROUGH */
4038 test_true(strncmp(value
, key
, len
) == 0);
4039 test_true(len
== length
);
4042 test_true(length
== len
* 2);
4045 test_true(length
== len
* 3);
4055 /* Try setting an illegal cas value (should not return an error to
4056 * the caller (because we don't expect a return message from the server)
4058 const char* keys
[]= {"0"};
4059 size_t lengths
[]= {1};
4062 memcached_result_st results_obj
;
4063 memcached_result_st
*results
;
4064 test_compare(MEMCACHED_SUCCESS
,
4065 memcached_mget(memc
, keys
, lengths
, 1));
4067 results
= memcached_result_create(memc
, &results_obj
);
4069 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4071 test_compare(MEMCACHED_SUCCESS
, ret
);
4072 uint64_t cas
= memcached_result_cas(results
);
4073 memcached_result_free(&results_obj
);
4075 test_compare(MEMCACHED_SUCCESS
,
4076 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4079 * The item will have a new cas value, so try to set it again with the old
4080 * value. This should fail!
4082 test_compare(MEMCACHED_SUCCESS
,
4083 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4084 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4085 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4086 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4089 return TEST_SUCCESS
;
4092 static test_return_t
analyzer_test(memcached_st
*memc
)
4094 memcached_return_t rc
;
4095 memcached_analysis_st
*report
;
4097 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4098 test_compare(MEMCACHED_SUCCESS
, rc
);
4099 test_true(memc_stat
);
4101 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4102 test_compare(MEMCACHED_SUCCESS
, rc
);
4106 memcached_stat_free(NULL
, memc_stat
);
4108 return TEST_SUCCESS
;
4111 /* Count the objects */
4113 static test_return_t
dump_test(memcached_st
*memc
)
4115 /* No support for Binary protocol yet */
4116 test_skip(false, memc
->flags
.binary_protocol
);
4118 test_compare(TEST_SUCCESS
, set_test3(memc
));
4120 // confirm_key_count() call dump
4121 size_t counter
= confirm_key_count(memc
);
4123 /* We may have more then 32 if our previous flush has not completed */
4124 test_true(counter
>= 32);
4126 return TEST_SUCCESS
;
4129 static test_return_t
util_version_test(memcached_st
*memc
)
4131 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
4132 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
4134 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4136 // We expect failure
4139 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4140 fprintf(stderr
, "\nDumping Server Information\n\n");
4141 memcached_server_fn callbacks
[1];
4143 callbacks
[0]= dump_server_information
;
4144 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4145 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4147 test_true(if_successful
== false);
4149 memcached_server_instance_st instance
=
4150 memcached_server_instance_by_position(memc
, 0);
4152 memcached_version(memc
);
4154 // We only use one binary when we test, so this should be just fine.
4155 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4156 test_true(if_successful
== true);
4158 if (instance
->micro_version
> 0)
4160 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4162 else if (instance
->minor_version
> 0)
4164 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4166 else if (instance
->major_version
> 0)
4168 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4171 test_true(if_successful
== true);
4173 if (instance
->micro_version
> 0)
4175 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4177 else if (instance
->minor_version
> 0)
4179 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4181 else if (instance
->major_version
> 0)
4183 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4186 test_true(if_successful
== false);
4188 return TEST_SUCCESS
;
4191 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4193 memcached_return_t rc
;
4194 memcached_server_instance_st instance
=
4195 memcached_server_instance_by_position(memc
, 0);
4197 // Test both the version that returns a code, and the one that does not.
4198 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4199 memcached_server_port(instance
) -1, NULL
) == -1);
4201 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4202 memcached_server_port(instance
) -1, &rc
) == -1);
4203 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4205 return TEST_SUCCESS
;
4209 static test_return_t
getpid_test(memcached_st
*memc
)
4211 memcached_return_t rc
;
4212 memcached_server_instance_st instance
=
4213 memcached_server_instance_by_position(memc
, 0);
4215 // Test both the version that returns a code, and the one that does not.
4216 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4217 memcached_server_port(instance
), NULL
) > -1);
4219 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4220 memcached_server_port(instance
), &rc
) > -1);
4221 test_compare(MEMCACHED_SUCCESS
, rc
);
4223 return TEST_SUCCESS
;
4226 static test_return_t
ping_test(memcached_st
*memc
)
4228 memcached_return_t rc
;
4229 memcached_server_instance_st instance
=
4230 memcached_server_instance_by_position(memc
, 0);
4232 // Test both the version that returns a code, and the one that does not.
4233 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4234 memcached_server_port(instance
), NULL
));
4236 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4237 memcached_server_port(instance
), &rc
));
4239 test_compare(MEMCACHED_SUCCESS
, rc
);
4241 return TEST_SUCCESS
;
4246 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4250 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4251 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4252 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4253 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4254 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4255 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4256 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4257 #ifdef HAVE_HSIEH_HASH
4258 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4260 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4261 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4262 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4264 return TEST_SUCCESS
;
4268 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4270 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4272 test_compare(MEMCACHED_SUCCESS
,
4273 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4274 (uint64_t)MEMCACHED_HASH_HSIEH
));
4276 return TEST_SUCCESS
;
4279 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4281 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4283 test_compare(MEMCACHED_SUCCESS
,
4284 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
4286 return TEST_SUCCESS
;
4289 static test_return_t
one_at_a_time_run (memcached_st
*)
4294 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4296 test_compare(one_at_a_time_values
[x
],
4297 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
4300 return TEST_SUCCESS
;
4303 static test_return_t
md5_run (memcached_st
*)
4308 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4310 test_compare(md5_values
[x
],
4311 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
4314 return TEST_SUCCESS
;
4317 static test_return_t
crc_run (memcached_st
*)
4322 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4324 test_compare(crc_values
[x
],
4325 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
4328 return TEST_SUCCESS
;
4331 static test_return_t
fnv1_64_run (memcached_st
*)
4333 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
4338 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4340 test_compare(fnv1_64_values
[x
],
4341 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
4344 return TEST_SUCCESS
;
4347 static test_return_t
fnv1a_64_run (memcached_st
*)
4349 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
4354 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4356 test_compare(fnv1a_64_values
[x
],
4357 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
4360 return TEST_SUCCESS
;
4363 static test_return_t
fnv1_32_run (memcached_st
*)
4368 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4370 test_compare(fnv1_32_values
[x
],
4371 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
4374 return TEST_SUCCESS
;
4377 static test_return_t
fnv1a_32_run (memcached_st
*)
4382 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4384 test_compare(fnv1a_32_values
[x
],
4385 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
4388 return TEST_SUCCESS
;
4391 static test_return_t
hsieh_run (memcached_st
*)
4393 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4398 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4400 test_compare(hsieh_values
[x
],
4401 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
4404 return TEST_SUCCESS
;
4407 static test_return_t
murmur_run (memcached_st
*)
4409 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4411 #ifdef WORDS_BIGENDIAN
4412 (void)murmur_values
;
4413 return TEST_SKIPPED
;
4418 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4420 test_compare(murmur_values
[x
],
4421 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
4424 return TEST_SUCCESS
;
4428 static test_return_t
jenkins_run (memcached_st
*)
4433 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4435 test_compare(jenkins_values
[x
],
4436 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
4439 return TEST_SUCCESS
;
4442 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
4444 return libhashkit_md5(string
, string_length
);
4447 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
4449 return libhashkit_crc32(string
, string_length
);
4452 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4458 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
4460 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};
4461 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};
4463 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4465 hashkit_clone(&new_kit
, kit
);
4466 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4468 memcached_set_hashkit(memc
, &new_kit
);
4471 Verify Setting the hash.
4473 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4477 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4478 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4483 Now check memcached_st.
4485 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4489 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4490 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4493 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4495 memcached_set_hashkit(memc
, &new_kit
);
4498 Verify Setting the hash.
4500 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4504 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4505 test_true(crc_values
[x
] == hash_val
);
4508 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4512 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4513 test_compare(crc_hosts
[x
], hash_val
);
4516 memcached_free(memc
);
4518 return TEST_SUCCESS
;
4522 Test case adapted from John Gorman <johngorman2@gmail.com>
4524 We are testing the error condition when we connect to a server via memcached_get()
4525 but find that the server is not available.
4527 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4529 const char *key
= "MemcachedLives";
4532 memcached_return rc
;
4535 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4537 // See if memcached is reachable.
4538 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4542 test_true(memcached_failed(rc
));
4544 memcached_free(tl_memc_h
);
4546 return TEST_SUCCESS
;
4550 We connect to a server which exists, but search for a key that does not exist.
4552 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4554 const char *key
= "MemcachedKeyNotEXIST";
4557 memcached_return rc
;
4559 // See if memcached is reachable.
4560 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4564 test_compare(MEMCACHED_NOTFOUND
, rc
);
4566 return TEST_SUCCESS
;
4570 Test case adapted from John Gorman <johngorman2@gmail.com>
4572 We are testing the error condition when we connect to a server via memcached_get_by_key()
4573 but find that the server is not available.
4575 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4578 memcached_st
*tl_memc_h
;
4579 memcached_server_st
*servers
;
4581 const char *key
= "MemcachedLives";
4584 memcached_return rc
;
4588 tl_memc_h
= memcached_create(NULL
);
4589 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4590 memcached_server_push(tl_memc_h
, servers
);
4591 memcached_server_list_free(servers
);
4593 // See if memcached is reachable.
4594 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4598 test_true(memcached_failed(rc
));
4600 memcached_free(tl_memc_h
);
4602 return TEST_SUCCESS
;
4606 We connect to a server which exists, but search for a key that does not exist.
4608 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4610 const char *key
= "MemcachedKeyNotEXIST";
4613 memcached_return rc
;
4616 // See if memcached is reachable.
4617 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4621 test_compare(MEMCACHED_NOTFOUND
, rc
);
4623 return TEST_SUCCESS
;
4626 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4628 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4630 const char *key
= "regression_bug_434484";
4631 size_t keylen
= strlen(key
);
4633 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4634 test_compare(MEMCACHED_NOTSTORED
, ret
);
4636 size_t size
= 2048 * 1024;
4637 char *data
= (char*)calloc(1, size
);
4639 test_compare(MEMCACHED_E2BIG
,
4640 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4643 return TEST_SUCCESS
;
4646 static test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4648 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4650 memcached_return_t rc
;
4652 memcached_execute_fn callbacks
[]= { &callback_counter
};
4655 * I only want to hit only _one_ server so I know the number of requests I'm
4656 * sending in the pipleine to the server. Let's try to do a multiget of
4657 * 1024 (that should satisfy most users don't you think?). Future versions
4658 * will include a mget_execute function call if you need a higher number.
4660 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4662 const size_t max_keys
= 1024;
4663 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4664 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4666 for (size_t x
= 0; x
< max_keys
; ++x
)
4670 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4676 * Run two times.. the first time we should have 100% cache miss,
4677 * and the second time we should have 100% cache hits
4679 for (size_t y
= 0; y
< 2; y
++)
4681 test_compare(MEMCACHED_SUCCESS
,
4682 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4684 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4685 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4689 /* The first iteration should give me a 100% cache miss. verify that*/
4690 char blob
[1024]= { 0 };
4692 test_false(counter
);
4694 for (size_t x
= 0; x
< max_keys
; ++x
)
4696 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4697 blob
, sizeof(blob
), 0, 0);
4698 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4703 /* Verify that we received all of the key/value pairs */
4704 test_compare(counter
, max_keys
);
4708 /* Release allocated resources */
4709 for (size_t x
= 0; x
< max_keys
; ++x
)
4716 memcached_free(memc
);
4718 return TEST_SUCCESS
;
4721 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4723 memcached_return_t rc
;
4724 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4725 test_compare(MEMCACHED_SUCCESS
, rc
);
4727 return regression_bug_434843(memc
);
4730 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4732 memcached_return_t rc
;
4733 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4734 test_compare(MEMCACHED_SUCCESS
, rc
);
4736 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4737 test_compare(MEMCACHED_SUCCESS
, rc
);
4738 test_true(bytes_str
);
4739 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4741 test_compare(MEMCACHED_SUCCESS
, rc
);
4742 test_true(bytes_read_str
);
4744 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4745 "bytes_written", &rc
);
4746 test_compare(MEMCACHED_SUCCESS
, rc
);
4747 test_true(bytes_written_str
);
4749 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4750 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4751 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4753 test_true(bytes
!= bytes_read
);
4754 test_true(bytes
!= bytes_written
);
4756 /* Release allocated resources */
4758 free(bytes_read_str
);
4759 free(bytes_written_str
);
4760 memcached_stat_free(NULL
, memc_stat
);
4762 return TEST_SUCCESS
;
4766 * The test case isn't obvious so I should probably document why
4767 * it works the way it does. Bug 442914 was caused by a bug
4768 * in the logic in memcached_purge (it did not handle the case
4769 * where the number of bytes sent was equal to the watermark).
4770 * In this test case, create messages so that we hit that case
4771 * and then disable noreply mode and issue a new command to
4772 * verify that it isn't stuck. If we change the format for the
4773 * delete command or the watermarks, we need to update this
4776 static test_return_t
regression_bug_442914(memcached_st
*memc
)
4778 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4779 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4781 uint32_t number_of_hosts
= memcached_server_count(memc
);
4782 memc
->number_of_hosts
= 1;
4787 for (uint32_t x
= 0; x
< 250; ++x
)
4789 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4790 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4791 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4794 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
4797 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4798 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4800 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4801 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
4803 memc
->number_of_hosts
= number_of_hosts
;
4805 return TEST_SUCCESS
;
4808 static test_return_t
regression_bug_447342(memcached_st
*memc
)
4810 memcached_server_instance_st instance_one
;
4811 memcached_server_instance_st instance_two
;
4813 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4814 return TEST_SKIPPED
;
4816 test_compare(MEMCACHED_SUCCESS
,
4817 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4819 const unsigned int max_keys
= 100;
4820 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4821 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4823 for (unsigned int x
= 0; x
< max_keys
; ++x
)
4827 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4830 test_compare(MEMCACHED_SUCCESS
,
4831 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
4835 ** We are using the quiet commands to store the replicas, so we need
4836 ** to ensure that all of them are processed before we can continue.
4837 ** In the test we go directly from storing the object to trying to
4838 ** receive the object from all of the different servers, so we
4839 ** could end up in a race condition (the memcached server hasn't yet
4840 ** processed the quiet command from the replication set when it process
4841 ** the request from the other client (created by the clone)). As a
4842 ** workaround for that we call memcached_quit to send the quit command
4843 ** to the server and wait for the response ;-) If you use the test code
4844 ** as an example for your own code, please note that you shouldn't need
4847 memcached_quit(memc
);
4849 /* Verify that all messages are stored, and we didn't stuff too much
4852 test_compare(MEMCACHED_SUCCESS
,
4853 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4855 unsigned int counter
= 0;
4856 memcached_execute_fn callbacks
[]= { &callback_counter
};
4857 test_compare(MEMCACHED_SUCCESS
,
4858 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4860 /* Verify that we received all of the key/value pairs */
4861 test_compare(counter
, max_keys
);
4863 memcached_quit(memc
);
4865 * Don't do the following in your code. I am abusing the internal details
4866 * within the library, and this is not a supported interface.
4867 * This is to verify correct behavior in the library. Fake that two servers
4870 instance_one
= memcached_server_instance_by_position(memc
, 0);
4871 instance_two
= memcached_server_instance_by_position(memc
, 2);
4872 in_port_t port0
= instance_one
->port
;
4873 in_port_t port2
= instance_two
->port
;
4875 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4876 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4878 test_compare(MEMCACHED_SUCCESS
,
4879 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4882 test_compare(MEMCACHED_SUCCESS
,
4883 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4884 test_compare(counter
, (unsigned int)max_keys
);
4886 /* restore the memc handle */
4887 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4888 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4890 memcached_quit(memc
);
4892 /* Remove half of the objects */
4893 for (size_t x
= 0; x
< max_keys
; ++x
)
4897 test_compare(MEMCACHED_SUCCESS
,
4898 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
4902 memcached_quit(memc
);
4903 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4904 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4906 /* now retry the command, this time we should have cache misses */
4907 test_compare(MEMCACHED_SUCCESS
,
4908 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4911 test_compare(MEMCACHED_SUCCESS
,
4912 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4913 test_compare(counter
, (unsigned int)(max_keys
>> 1));
4915 /* Release allocated resources */
4916 for (size_t x
= 0; x
< max_keys
; ++x
)
4923 /* restore the memc handle */
4924 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4925 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4927 return TEST_SUCCESS
;
4930 static test_return_t
regression_bug_463297(memcached_st
*memc
)
4932 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4933 test_true(memc_clone
);
4934 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4936 memcached_server_instance_st instance
=
4937 memcached_server_instance_by_position(memc_clone
, 0);
4939 if (instance
->major_version
> 1 ||
4940 (instance
->major_version
== 1 &&
4941 instance
->minor_version
> 2))
4943 /* Binary protocol doesn't support deferred delete */
4944 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4945 test_true(bin_clone
);
4946 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4947 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4948 memcached_free(bin_clone
);
4950 memcached_quit(memc_clone
);
4952 /* If we know the server version, deferred delete should fail
4953 * with invalid arguments */
4954 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4956 /* If we don't know the server version, we should get a protocol error */
4957 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4959 /* but there is a bug in some of the memcached servers (1.4) that treats
4960 * the counter as noreply so it doesn't send the proper error message
4962 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4964 /* And buffered mode should be disabled and we should get protocol error */
4965 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4966 rc
= memcached_delete(memc
, "foo", 3, 1);
4967 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4969 /* Same goes for noreply... */
4970 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4971 rc
= memcached_delete(memc
, "foo", 3, 1);
4972 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4974 /* but a normal request should go through (and be buffered) */
4975 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4976 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4978 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4979 /* unbuffered noreply should be success */
4980 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4981 /* unbuffered with reply should be not found... */
4982 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4983 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4986 memcached_free(memc_clone
);
4987 return TEST_SUCCESS
;
4991 /* Test memcached_server_get_last_disconnect
4992 * For a working server set, shall be NULL
4993 * For a set of non existing server, shall not be NULL
4995 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4997 memcached_return_t rc
;
4998 memcached_server_instance_st disconnected_server
;
5000 /* With the working set of server */
5001 const char *key
= "marmotte";
5002 const char *value
= "milka";
5004 memcached_reset_last_disconnected_server(memc
);
5005 test_false(memc
->last_disconnected_server
);
5006 rc
= memcached_set(memc
, key
, strlen(key
),
5007 value
, strlen(value
),
5008 (time_t)0, (uint32_t)0);
5009 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5011 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5012 test_false(disconnected_server
);
5014 /* With a non existing server */
5016 memcached_server_st
*servers
;
5018 const char *server_list
= "localhost:9";
5020 servers
= memcached_servers_parse(server_list
);
5022 mine
= memcached_create(NULL
);
5023 rc
= memcached_server_push(mine
, servers
);
5024 test_compare(MEMCACHED_SUCCESS
, rc
);
5025 memcached_server_list_free(servers
);
5028 rc
= memcached_set(mine
, key
, strlen(key
),
5029 value
, strlen(value
),
5030 (time_t)0, (uint32_t)0);
5031 test_true(memcached_failed(rc
));
5033 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5034 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5035 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5036 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5038 memcached_quit(mine
);
5039 memcached_free(mine
);
5041 return TEST_SUCCESS
;
5044 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5046 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5047 char buffer
[BUFSIZ
];
5049 test_compare(MEMCACHED_SUCCESS
,
5050 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5052 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5055 // We will just use the error strings as our keys
5056 uint32_t counter
= 100;
5059 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5061 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5062 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5063 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
5065 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5066 test_true(disconnected_server
);
5067 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5068 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5072 memcached_reset_last_disconnected_server(memc
);
5077 memcached_free(memc
);
5079 return TEST_SUCCESS
;
5082 static test_return_t
test_verbosity(memcached_st
*memc
)
5084 memcached_verbosity(memc
, 3);
5086 return TEST_SUCCESS
;
5090 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5091 const char *key
, size_t key_length
,
5092 const char *value
, size_t value_length
,
5102 return MEMCACHED_SUCCESS
;
5105 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5107 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5108 test_compare(MEMCACHED_SUCCESS
, rc
);
5110 test_compare(MEMCACHED_SUCCESS
,
5111 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
5113 test_compare(MEMCACHED_SUCCESS
,
5114 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
5116 test_compare(MEMCACHED_SUCCESS
,
5117 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
5119 return TEST_SUCCESS
;
5123 * This test ensures that the failure counter isn't incremented during
5124 * normal termination of the memcached instance.
5126 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5128 memcached_return_t rc
;
5129 memcached_server_instance_st instance
;
5131 /* Set value to force connection to the server */
5132 const char *key
= "marmotte";
5133 const char *value
= "milka";
5136 * Please note that I'm abusing the internal structures in libmemcached
5137 * in a non-portable way and you shouldn't be doing this. I'm only
5138 * doing this in order to verify that the library works the way it should
5140 uint32_t number_of_hosts
= memcached_server_count(memc
);
5141 memc
->number_of_hosts
= 1;
5143 /* Ensure that we are connected to the server by setting a value */
5144 rc
= memcached_set(memc
, key
, strlen(key
),
5145 value
, strlen(value
),
5146 (time_t)0, (uint32_t)0);
5147 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5150 instance
= memcached_server_instance_by_position(memc
, 0);
5151 /* The test is to see that the memcached_quit doesn't increase the
5152 * the server failure conter, so let's ensure that it is zero
5153 * before sending quit
5155 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5157 memcached_quit(memc
);
5159 /* Verify that it memcached_quit didn't increment the failure counter
5160 * Please note that this isn't bullet proof, because an error could
5163 test_zero(instance
->server_failure_counter
);
5165 /* restore the instance */
5166 memc
->number_of_hosts
= number_of_hosts
;
5168 return TEST_SUCCESS
;
5172 * This tests ensures expected disconnections (for some behavior changes
5173 * for instance) do not wrongly increase failure counter
5175 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5177 /* Set value to force connection to the server */
5178 const char *key
= "marmotte";
5179 const char *value
= "milka";
5181 test_compare_hint(MEMCACHED_SUCCESS
,
5182 memcached_set(memc
, key
, strlen(key
),
5183 value
, strlen(value
),
5184 (time_t)0, (uint32_t)0),
5185 memcached_last_error_message(memc
));
5188 /* put failure limit to 1 */
5189 test_compare(MEMCACHED_SUCCESS
,
5190 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
5192 /* Put a retry timeout to effectively activate failure_limit effect */
5193 test_compare(MEMCACHED_SUCCESS
,
5194 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
5196 /* change behavior that triggers memcached_quit()*/
5197 test_compare(MEMCACHED_SUCCESS
,
5198 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
5201 /* Check if we still are connected */
5203 size_t string_length
;
5204 memcached_return rc
;
5205 char *string
= memcached_get(memc
, key
, strlen(key
),
5206 &string_length
, &flags
, &rc
);
5208 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5212 return TEST_SUCCESS
;
5217 * Test that ensures mget_execute does not end into recursive calls that finally fails
5219 static test_return_t
regression_bug_490486(memcached_st
*original_memc
)
5223 return TEST_SKIPPED
; // My MAC can't handle this test
5226 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
5229 * I only want to hit _one_ server so I know the number of requests I'm
5230 * sending in the pipeline.
5232 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
5235 size_t max_keys
= 20480;
5237 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5238 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5240 /* First add all of the items.. */
5241 char blob
[1024]= { 0 };
5242 for (size_t x
= 0; x
< max_keys
; ++x
)
5245 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5248 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5249 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5254 /* Try to get all of them with a large multiget */
5256 memcached_execute_function callbacks
[]= { &callback_counter
};
5257 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5258 (size_t)max_keys
, callbacks
, &counter
, 1);
5259 test_compare(MEMCACHED_SUCCESS
, rc
);
5261 char* the_value
= NULL
;
5262 char the_key
[MEMCACHED_MAX_KEY
];
5263 size_t the_key_length
;
5264 size_t the_value_length
;
5268 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5270 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5276 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5279 test_compare(MEMCACHED_END
, rc
);
5281 /* Verify that we got all of the items */
5282 test_compare(counter
, max_keys
);
5285 /* Release all allocated resources */
5286 for (size_t x
= 0; x
< max_keys
; ++x
)
5293 memcached_free(memc
);
5295 return TEST_SUCCESS
;
5298 static test_return_t
regression_bug_583031(memcached_st
*)
5300 memcached_st
*memc
= memcached_create(NULL
);
5302 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5304 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5305 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5306 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5307 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5308 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5309 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5311 memcached_return_t rc
;
5315 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5319 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5321 memcached_free(memc
);
5323 return TEST_SUCCESS
;
5326 static test_return_t
regression_bug_581030(memcached_st
*)
5329 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5330 test_false(local_stat
);
5332 memcached_stat_free(NULL
, NULL
);
5335 return TEST_SUCCESS
;
5338 #define regression_bug_655423_COUNT 6000
5339 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5341 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5342 memc
= NULL
; // Just to make sure it is not used
5347 return TEST_SKIPPED
;
5350 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5351 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5352 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5353 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5355 memset(payload
, int('x'), sizeof(payload
));
5357 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5359 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5360 snprintf(key
, sizeof(key
), "%u", x
);
5362 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5365 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5367 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5368 snprintf(key
, sizeof(key
), "%u", x
);
5370 size_t value_length
;
5371 memcached_return_t rc
;
5372 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5374 if (rc
== MEMCACHED_NOTFOUND
)
5377 test_zero(value_length
);
5381 test_compare(MEMCACHED_SUCCESS
, rc
);
5383 test_compare(100LLU, value_length
);
5387 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5388 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5389 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5391 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5392 snprintf(key
, sizeof(key
), "%u", x
);
5394 keys
[x
]= strdup(key
);
5396 key_length
[x
]= strlen(key
);
5397 test_true(key_length
[x
]);
5400 test_compare(MEMCACHED_SUCCESS
,
5401 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5404 memcached_result_st
*result
= NULL
;
5405 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5407 test_compare(size_t(100), memcached_result_length(result
));
5411 test_true(count
> 100); // If we don't get back atleast this, something is up
5413 /* Release all allocated resources */
5414 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5422 memcached_free(clone
);
5424 return TEST_SUCCESS
;
5428 * Test that ensures that buffered set to not trigger problems during io_flush
5430 #define regression_bug_490520_COUNT 200480
5431 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5433 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5434 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5435 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5436 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5437 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5439 memc
->number_of_hosts
= 1;
5441 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5442 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5444 /* First add all of the items.. */
5445 char blob
[3333] = {0};
5446 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5449 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5453 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5454 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5457 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5464 return TEST_SUCCESS
;
5468 static test_return_t
regression_bug_854604(memcached_st
*)
5472 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
5474 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
5476 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
5477 test_compare(buffer
[0], 0);
5479 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
5480 test_true(strlen(buffer
));
5482 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
5483 test_true(strlen(buffer
));
5485 return TEST_SUCCESS
;
5488 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5490 fprintf(stderr
, "Iteration #%u: ", it
);
5492 if (error
== MEMCACHED_ERRNO
)
5494 fprintf(stderr
, "system error %d from %s: %s\n",
5495 errno
, what
, strerror(errno
));
5499 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5500 memcached_strerror(mc
, error
));
5504 #define TEST_CONSTANT_CREATION 200
5506 static test_return_t
regression_bug_(memcached_st
*memc
)
5508 const char *remote_server
;
5511 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5513 return TEST_SKIPPED
;
5516 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5518 memcached_st
* mc
= memcached_create(NULL
);
5519 memcached_return rc
;
5521 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5522 if (rc
!= MEMCACHED_SUCCESS
)
5524 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5527 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5528 if (rc
!= MEMCACHED_SUCCESS
)
5530 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5533 rc
= memcached_server_add(mc
, remote_server
, 0);
5534 if (rc
!= MEMCACHED_SUCCESS
)
5536 memcached_die(mc
, rc
, "memcached_server_add", x
);
5539 const char *set_key
= "akey";
5540 const size_t set_key_len
= strlen(set_key
);
5541 const char *set_value
= "a value";
5542 const size_t set_value_len
= strlen(set_value
);
5544 if (rc
== MEMCACHED_SUCCESS
)
5548 size_t get_value_len
;
5550 uint32_t get_value_flags
;
5552 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5553 &get_value_flags
, &rc
);
5554 if (rc
!= MEMCACHED_SUCCESS
)
5556 memcached_die(mc
, rc
, "memcached_get", x
);
5562 (get_value_len
!= set_value_len
5563 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5565 fprintf(stderr
, "Values don't match?\n");
5566 rc
= MEMCACHED_FAILURE
;
5572 rc
= memcached_set(mc
,
5573 set_key
, set_key_len
,
5574 set_value
, set_value_len
,
5578 if (rc
!= MEMCACHED_SUCCESS
)
5580 memcached_die(mc
, rc
, "memcached_set", x
);
5587 if (rc
!= MEMCACHED_SUCCESS
)
5593 return TEST_SUCCESS
;
5596 /* Clean the server before beginning testing */
5598 {"util_version", true, (test_callback_fn
*)util_version_test
},
5599 {"flush", false, (test_callback_fn
*)flush_test
},
5600 {"init", false, (test_callback_fn
*)init_test
},
5601 {"allocation", false, (test_callback_fn
*)allocation_test
},
5602 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5603 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5604 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5605 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5606 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5607 {"clone_test", false, (test_callback_fn
*)clone_test
},
5608 {"connection_test", false, (test_callback_fn
*)connection_test
},
5609 {"callback_test", false, (test_callback_fn
*)callback_test
},
5610 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5611 {"set", false, (test_callback_fn
*)set_test
},
5612 {"set2", false, (test_callback_fn
*)set_test2
},
5613 {"set3", false, (test_callback_fn
*)set_test3
},
5614 {"dump", true, (test_callback_fn
*)dump_test
},
5615 {"add", true, (test_callback_fn
*)add_test
},
5616 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5617 {"replace", true, (test_callback_fn
*)replace_test
},
5618 {"delete", true, (test_callback_fn
*)delete_test
},
5619 {"get", true, (test_callback_fn
*)get_test
},
5620 {"get2", false, (test_callback_fn
*)get_test2
},
5621 {"get3", false, (test_callback_fn
*)get_test3
},
5622 {"get4", false, (test_callback_fn
*)get_test4
},
5623 {"partial mget", false, (test_callback_fn
*)get_test5
},
5624 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5625 {"increment", false, (test_callback_fn
*)increment_test
},
5626 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5627 {"decrement", false, (test_callback_fn
*)decrement_test
},
5628 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5629 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5630 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5631 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5632 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5633 {"binary_increment_with_prefix", 1, (test_callback_fn
*)binary_increment_with_prefix_test
},
5634 {"quit", false, (test_callback_fn
*)quit_test
},
5635 {"mget", true, (test_callback_fn
*)mget_test
},
5636 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5637 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5638 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5639 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5640 {"mget_end", false, (test_callback_fn
*)mget_end
},
5641 {"get_stats", false, (test_callback_fn
*)get_stats
},
5642 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5643 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5644 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5645 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
5646 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5647 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5648 {"read_through", true, (test_callback_fn
*)read_through
},
5649 {"delete_through", true, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER
},
5650 {"noreply", true, (test_callback_fn
*)noreply_test
},
5651 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5652 {"memcached_pool_st", true, (test_callback_fn
*)connection_pool_test
},
5653 {"memcached_pool_st #2", true, (test_callback_fn
*)connection_pool2_test
},
5655 {"memcached_pool_st #3", true, (test_callback_fn
*)connection_pool3_test
},
5657 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
5658 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
5659 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
5660 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
5661 {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_NOTFOUND
},
5662 {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_SUCCESS
},
5663 {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_by_key_NOTFOUND
},
5664 {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_by_key_SUCCESS
},
5665 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5666 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5670 test_st touch_tests
[] ={
5671 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5672 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5676 test_st behavior_tests
[] ={
5677 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5678 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5679 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5680 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5681 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5682 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5683 {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test
},
5684 {"MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY", false, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY
},
5688 test_st libmemcachedutil_tests
[] ={
5689 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5690 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5691 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5695 test_st basic_tests
[] ={
5696 {"init", true, (test_callback_fn
*)basic_init_test
},
5697 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5698 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5699 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5700 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5701 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5702 {"memcached_return_t", false, (test_callback_fn
*)memcached_return_t_TEST
},
5706 test_st regression_binary_vs_block
[] ={
5707 {"block add", true, (test_callback_fn
*)block_add_regression
},
5708 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
5712 test_st async_tests
[] ={
5713 {"add", true, (test_callback_fn
*)add_wrapper
},
5717 test_st memcached_server_get_last_disconnect_tests
[] ={
5718 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
5719 {0, 0, (test_callback_fn
*)0}
5723 test_st result_tests
[] ={
5724 {"result static", false, (test_callback_fn
*)result_static
},
5725 {"result alloc", false, (test_callback_fn
*)result_alloc
},
5726 {0, 0, (test_callback_fn
*)0}
5729 test_st version_1_2_3
[] ={
5730 {"append", false, (test_callback_fn
*)append_test
},
5731 {"prepend", false, (test_callback_fn
*)prepend_test
},
5732 {"cas", false, (test_callback_fn
*)cas_test
},
5733 {"cas2", false, (test_callback_fn
*)cas2_test
},
5734 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
5735 {0, 0, (test_callback_fn
*)0}
5738 test_st haldenbrand_tests
[] ={
5739 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
5740 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
5741 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
5742 {0, 0, (test_callback_fn
*)0}
5745 test_st user_tests
[] ={
5746 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
5747 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
5748 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
5749 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
5750 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
5751 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
5752 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
5753 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
5754 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
5755 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
5756 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
5757 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
5758 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
5759 #if !defined(__sun) && !defined(__OpenBSD__)
5761 ** It seems to be something weird with the character sets..
5762 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5763 ** guess I need to find out how this is supposed to work.. Perhaps I need
5764 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5765 ** so just disable the code for now...).
5767 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
5769 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
5770 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
5771 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
5772 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
5773 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
5774 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
5775 {0, 0, (test_callback_fn
*)0}
5778 test_st replication_tests
[]= {
5779 {"set", true, (test_callback_fn
*)replication_set_test
},
5780 {"get", false, (test_callback_fn
*)replication_get_test
},
5781 {"mget", false, (test_callback_fn
*)replication_mget_test
},
5782 {"delete", true, (test_callback_fn
*)replication_delete_test
},
5783 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
5784 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
5785 {0, 0, (test_callback_fn
*)0}
5789 * The following test suite is used to verify that we don't introduce
5790 * regression bugs. If you want more information about the bug / test,
5791 * you should look in the bug report at
5792 * http://bugs.launchpad.net/libmemcached
5794 test_st regression_tests
[]= {
5795 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
5796 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
5797 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
5798 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
5799 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
5800 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
5801 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
5802 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
5803 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
5804 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
5805 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
5806 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
5807 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
5808 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
5809 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
5810 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
5811 {"lp:854604", true, (test_callback_fn
*)regression_bug_854604
},
5812 {0, false, (test_callback_fn
*)0}
5815 test_st ketama_compatibility
[]= {
5816 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
5817 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
5818 {0, 0, (test_callback_fn
*)0}
5821 test_st generate_tests
[] ={
5822 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5823 {"generate_data", true, (test_callback_fn
*)generate_data
},
5824 {"get_read", false, (test_callback_fn
*)get_read
},
5825 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
5826 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5827 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
5828 {"generate_data", true, (test_callback_fn
*)generate_data
},
5829 {"mget_read", false, (test_callback_fn
*)mget_read
},
5830 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
5831 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
5832 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
5833 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
5834 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5835 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
5836 {"generate_data", true, (test_callback_fn
*)generate_data
},
5837 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5838 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5839 {0, 0, (test_callback_fn
*)0}
5842 test_st consistent_tests
[] ={
5843 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5844 {"generate_data", true, (test_callback_fn
*)generate_data
},
5845 {"get_read", 0, (test_callback_fn
*)get_read_count
},
5846 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5847 {0, 0, (test_callback_fn
*)0}
5850 test_st consistent_weighted_tests
[] ={
5851 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5852 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
5853 {"get_read", false, (test_callback_fn
*)get_read_count
},
5854 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5855 {0, 0, (test_callback_fn
*)0}
5858 test_st hsieh_availability
[] ={
5859 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
5860 {0, 0, (test_callback_fn
*)0}
5863 test_st murmur_availability
[] ={
5864 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
5865 {0, 0, (test_callback_fn
*)0}
5869 test_st hash_sanity
[] ={
5870 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
5871 {0, 0, (test_callback_fn
*)0}
5875 test_st ketama_auto_eject_hosts
[] ={
5876 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
5877 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
5878 {0, 0, (test_callback_fn
*)0}
5881 test_st hash_tests
[] ={
5882 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
5883 {"md5", false, (test_callback_fn
*)md5_run
},
5884 {"crc", false, (test_callback_fn
*)crc_run
},
5885 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
5886 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
5887 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
5888 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
5889 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
5890 {"murmur", false, (test_callback_fn
*)murmur_run
},
5891 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
5892 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
5893 {0, 0, (test_callback_fn
*)0}
5896 test_st error_conditions
[] ={
5897 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
5898 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
5899 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
5900 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5901 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5902 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
5903 {0, 0, (test_callback_fn
*)0}
5906 test_st parser_tests
[] ={
5907 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
5908 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
5909 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
5910 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
5911 {"hash", false, (test_callback_fn
*)parser_hash_test
},
5912 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
5913 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
5914 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
5915 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
5916 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
5917 {"server", false, (test_callback_fn
*)server_test
},
5918 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
5919 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
5920 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
5921 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
5922 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
5923 {0, 0, (test_callback_fn
*)0}
5926 test_st virtual_bucket_tests
[] ={
5927 {"basic", false, (test_callback_fn
*)virtual_back_map
},
5928 {0, 0, (test_callback_fn
*)0}
5931 test_st memcached_server_add_tests
[] ={
5932 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
5933 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
5934 {0, 0, (test_callback_fn
*)0}
5937 test_st namespace_tests
[] ={
5938 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
5939 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
5940 {0, 0, (test_callback_fn
*)0}
5943 collection_st collection
[] ={
5945 {"hash_sanity", 0, 0, hash_sanity
},
5947 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
5948 {"basic", 0, 0, basic_tests
},
5949 {"hsieh_availability", 0, 0, hsieh_availability
},
5950 {"murmur_availability", 0, 0, murmur_availability
},
5951 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
5952 {"block", 0, 0, tests
},
5953 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
5954 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
5955 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5956 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
5957 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
5958 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
5959 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
5960 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
5961 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
5962 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
5963 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
5964 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
5965 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
5966 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
5967 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
5968 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5969 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
5970 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
5971 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
5972 #ifdef MEMCACHED_ENABLE_DEPRECATED
5973 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
5975 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
5976 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
5977 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
5978 {"specific namespace", 0, 0, namespace_tests
},
5979 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
5980 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
5981 {"result", 0, 0, result_tests
},
5982 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
5983 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
5984 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
5985 {"user written tests", 0, 0, user_tests
},
5986 {"generate", 0, 0, generate_tests
},
5987 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
5988 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
5989 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
5990 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
5991 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
5992 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
5993 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
5995 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
5996 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
5997 {"consistent_not", 0, 0, consistent_tests
},
5998 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
5999 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6000 {"ketama_compat", 0, 0, ketama_compatibility
},
6001 {"test_hashes", 0, 0, hash_tests
},
6002 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6003 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6004 {"regression", 0, 0, regression_tests
},
6005 {"behaviors", 0, 0, behavior_tests
},
6006 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6007 {"error_conditions", 0, 0, error_conditions
},
6008 {"parser", 0, 0, parser_tests
},
6009 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6010 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6011 {"touch", 0, 0, touch_tests
},
6015 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
6017 #include "tests/libmemcached_world.h"
6019 void get_world(Framework
*world
)
6021 world
->collections
= collection
;
6023 world
->_create
= (test_callback_create_fn
*)world_create
;
6024 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6026 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6027 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6028 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6029 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6030 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6032 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6033 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6035 world
->set_runner(&defualt_libmemcached_runner
);
6037 world
->set_socket();