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/libmemcached-1.0/dump.h"
82 #include "tests/touch.h"
83 #include "tests/callbacks.h"
84 #include "tests/pool.h"
85 #include "tests/print.h"
86 #include "tests/replication.h"
87 #include "tests/server_add.h"
88 #include "tests/virtual_buckets.h"
90 using namespace libtest
;
92 #include <libmemcached/util.h>
94 #include "tests/hash_results.h"
96 #define GLOBAL_COUNT 10000
97 #define GLOBAL2_COUNT 100
98 #define SERVERS_TO_CREATE 5
99 static uint32_t global_count
= GLOBAL2_COUNT
;
101 static pairs_st
*global_pairs
;
102 static const char *global_keys
[GLOBAL_COUNT
];
103 static size_t global_keys_length
[GLOBAL_COUNT
];
106 @note This should be testing to see if the server really supports the binary protocol.
108 static test_return_t
pre_binary(memcached_st
*memc
)
110 test_skip(true, libmemcached_util_version_check(memc
, 1, 4, 4));
111 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
116 static memcached_return_t
return_value_based_on_buffering(memcached_st
*memc
)
118 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
))
120 return MEMCACHED_BUFFERED
;
123 return MEMCACHED_SUCCESS
;
126 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
129 * I only want to hit _one_ server so I know the number of requests I'm
130 * sending in the pipeline.
132 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
134 char server_string
[1024];
135 int server_string_length
;
138 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
139 memcached_server_name(instance
), int(memcached_server_port(instance
)),
144 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
145 memcached_server_name(instance
), int(memcached_server_port(instance
)));
148 if (server_string_length
<= 0)
154 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, buffer
, sizeof(buffer
))))
156 Error
<< "Failed to parse " << server_string_length
;
160 return memcached(server_string
, server_string_length
);
164 static test_return_t
init_test(memcached_st
*not_used
)
169 (void)memcached_create(&memc
);
170 memcached_free(&memc
);
175 #define TEST_PORT_COUNT 7
176 in_port_t test_ports
[TEST_PORT_COUNT
];
178 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
179 const memcached_server_st
*server
,
183 size_t bigger
= *((size_t *)(context
));
185 assert(bigger
<= memcached_server_port(server
));
186 *((size_t *)(context
))= memcached_server_port(server
);
188 return MEMCACHED_SUCCESS
;
191 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
192 const memcached_server_st
*instance
,
196 FILE *stream
= (FILE *)context
;
199 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
200 memcached_server_name(instance
),
201 memcached_server_port(instance
),
202 instance
->major_version
,
203 instance
->minor_version
,
204 instance
->micro_version
);
206 return MEMCACHED_SUCCESS
;
209 static test_return_t
server_sort_test(memcached_st
*ptr
)
211 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
213 memcached_return_t rc
;
214 memcached_server_fn callbacks
[1];
215 memcached_st
*local_memc
;
218 local_memc
= memcached_create(NULL
);
219 test_true(local_memc
);
220 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
222 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
224 test_ports
[x
]= (in_port_t
)random() % 64000;
225 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
226 test_compare(memcached_server_count(local_memc
), x
+1);
228 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
230 test_compare(MEMCACHED_SUCCESS
, rc
);
233 callbacks
[0]= server_display_function
;
234 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
237 memcached_free(local_memc
);
242 static test_return_t
server_sort2_test(memcached_st
*ptr
)
244 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
245 memcached_server_fn callbacks
[1];
246 memcached_st
*local_memc
;
247 memcached_server_instance_st instance
;
250 local_memc
= memcached_create(NULL
);
251 test_true(local_memc
);
252 test_compare(MEMCACHED_SUCCESS
,
253 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
255 test_compare(MEMCACHED_SUCCESS
,
256 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
257 instance
= memcached_server_instance_by_position(local_memc
, 0);
258 test_compare(in_port_t(43043), memcached_server_port(instance
));
260 test_compare(MEMCACHED_SUCCESS
,
261 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
263 instance
= memcached_server_instance_by_position(local_memc
, 0);
264 test_compare(in_port_t(43042), memcached_server_port(instance
));
266 instance
= memcached_server_instance_by_position(local_memc
, 1);
267 test_compare(in_port_t(43043), memcached_server_port(instance
));
269 callbacks
[0]= server_display_function
;
270 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
273 memcached_free(local_memc
);
278 static test_return_t
memcached_server_remove_test(memcached_st
*)
280 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";
283 test_compare(MEMCACHED_SUCCESS
,
284 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
285 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
288 memcached_server_fn callbacks
[1];
289 callbacks
[0]= server_print_callback
;
290 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
292 memcached_free(memc
);
297 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
298 const memcached_server_st
*server
,
302 uint32_t x
= *((uint32_t *)(context
));
304 if (! (test_ports
[x
] == server
->port
))
306 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
307 return MEMCACHED_FAILURE
;
310 *((uint32_t *)(context
))= ++x
;
312 return MEMCACHED_SUCCESS
;
315 static test_return_t
server_unsort_test(memcached_st
*ptr
)
317 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
318 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
319 memcached_server_fn callbacks
[1];
320 memcached_st
*local_memc
;
323 local_memc
= memcached_create(NULL
);
324 test_true(local_memc
);
326 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
328 test_ports
[x
]= (in_port_t
)(random() % 64000);
329 test_compare(MEMCACHED_SUCCESS
,
330 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
331 test_compare(memcached_server_count(local_memc
), x
+1);
333 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
337 callbacks
[0]= server_display_unsort_function
;
338 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
340 /* Now we sort old data! */
341 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
342 callbacks
[0]= server_display_function
;
343 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
346 memcached_free(local_memc
);
351 static test_return_t
allocation_test(memcached_st
*not_used
)
355 memc
= memcached_create(NULL
);
357 memcached_free(memc
);
362 static test_return_t
clone_test(memcached_st
*memc
)
366 memcached_st
*memc_clone
;
367 memc_clone
= memcached_clone(NULL
, NULL
);
368 test_true(memc_clone
);
369 memcached_free(memc_clone
);
372 /* Can we init from null? */
374 memcached_st
*memc_clone
;
375 memc_clone
= memcached_clone(NULL
, memc
);
376 test_true(memc_clone
);
379 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
380 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
381 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
382 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
385 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
386 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
387 test_true(memc_clone
->distribution
== memc
->distribution
);
388 { // Test all of the flags
389 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
390 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
391 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
392 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
393 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
394 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
395 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
396 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
397 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
398 test_true(memc_clone
->flags
.reply
== memc
->flags
.reply
);
399 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
400 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
401 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
403 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
404 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
405 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
406 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
407 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
408 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
409 test_true(memc_clone
->on_clone
== memc
->on_clone
);
410 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
411 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
412 test_true(memc_clone
->recv_size
== memc
->recv_size
);
413 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
414 test_true(memc_clone
->send_size
== memc
->send_size
);
415 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
416 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
417 test_true(memc_clone
->user_data
== memc
->user_data
);
419 memcached_free(memc_clone
);
422 /* Can we init from struct? */
424 memcached_st declared_clone
;
425 memcached_st
*memc_clone
;
426 memset(&declared_clone
, 0 , sizeof(memcached_st
));
427 memc_clone
= memcached_clone(&declared_clone
, NULL
);
428 test_true(memc_clone
);
429 memcached_free(memc_clone
);
432 /* Can we init from struct? */
434 memcached_st declared_clone
;
435 memcached_st
*memc_clone
;
436 memset(&declared_clone
, 0 , sizeof(memcached_st
));
437 memc_clone
= memcached_clone(&declared_clone
, memc
);
438 test_true(memc_clone
);
439 memcached_free(memc_clone
);
445 static test_return_t
userdata_test(memcached_st
*memc
)
448 test_false(memcached_set_user_data(memc
, foo
));
449 test_true(memcached_get_user_data(memc
) == foo
);
450 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
455 static test_return_t
connection_test(memcached_st
*memc
)
457 test_compare(MEMCACHED_SUCCESS
,
458 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
463 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
465 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
467 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
469 test_compare(37, int(MEMCACHED_BEHAVIOR_MAX
));
474 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
476 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
478 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
480 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
485 static test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
487 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
488 982370485U, 1263635348U, 4242906218U, 3829656100U,
489 1891735253U, 334139633U, 2257084983U, 3088286104U,
490 13199785U, 2542027183U, 1097051614U, 199566778U,
491 2748246961U, 2465192557U, 1664094137U, 2405439045U,
492 1842224848U, 692413798U, 3479807801U, 919913813U,
493 4269430871U, 610793021U, 527273862U, 1437122909U,
494 2300930706U, 2943759320U, 674306647U, 2400528935U,
495 54481931U, 4186304426U, 1741088401U, 2979625118U,
496 4159057246U, 3425930182U, 2593724503U, 1868899624U,
497 1769812374U, 2302537950U, 1110330676U, 3365377466U,
498 1336171666U, 3021258493U, 2334992265U, 3861994737U,
499 3582734124U, 3365377466U };
501 // You have updated the memcache_error messages but not updated docs/tests.
502 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
505 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
506 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
507 MEMCACHED_HASH_JENKINS
);
508 if (values
[rc
] != hash_val
)
510 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
511 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
513 test_compare(values
[rc
], hash_val
);
515 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
520 static test_return_t
set_test(memcached_st
*memc
)
522 memcached_return_t rc
= memcached_set(memc
,
523 test_literal_param("foo"),
524 test_literal_param("when we sanitize"),
525 time_t(0), (uint32_t)0);
526 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
531 static test_return_t
append_test(memcached_st
*memc
)
533 memcached_return_t rc
;
534 const char *in_value
= "we";
538 test_compare(MEMCACHED_SUCCESS
,
539 memcached_flush(memc
, 0));
541 test_compare(MEMCACHED_SUCCESS
,
543 test_literal_param(__func__
),
544 in_value
, strlen(in_value
),
545 time_t(0), uint32_t(0)));
547 test_compare(MEMCACHED_SUCCESS
,
548 memcached_append(memc
,
549 test_literal_param(__func__
),
550 " the", strlen(" the"),
551 time_t(0), uint32_t(0)));
553 test_compare(MEMCACHED_SUCCESS
,
554 memcached_append(memc
,
555 test_literal_param(__func__
),
556 " people", strlen(" people"),
557 time_t(0), uint32_t(0)));
559 char *out_value
= memcached_get(memc
,
560 test_literal_param(__func__
),
561 &value_length
, &flags
, &rc
);
562 test_memcmp(out_value
, "we the people", strlen("we the people"));
563 test_compare(strlen("we the people"), value_length
);
564 test_compare(MEMCACHED_SUCCESS
, rc
);
570 static test_return_t
append_binary_test(memcached_st
*memc
)
572 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
574 test_compare(MEMCACHED_SUCCESS
,
575 memcached_flush(memc
, 0));
577 test_compare(MEMCACHED_SUCCESS
,
579 test_literal_param(__func__
),
581 time_t(0), uint32_t(0)));
584 for (uint32_t x
= 0; store_list
[x
] ; x
++)
586 test_compare(MEMCACHED_SUCCESS
,
587 memcached_append(memc
,
588 test_literal_param(__func__
),
589 (char *)&store_list
[x
], sizeof(uint32_t),
590 time_t(0), uint32_t(0)));
596 memcached_return_t rc
;
597 uint32_t *value
= (uint32_t *)memcached_get(memc
,
598 test_literal_param(__func__
),
599 &value_length
, &flags
, &rc
);
600 test_compare(value_length
, sizeof(uint32_t) * count
);
601 test_compare(MEMCACHED_SUCCESS
, rc
);
603 for (uint32_t counter
= count
, *ptr
= value
; counter
; counter
--)
605 test_compare(*ptr
, store_list
[count
- counter
]);
613 static test_return_t
cas2_test(memcached_st
*memc
)
615 const char *keys
[]= {"fudge", "son", "food"};
616 size_t key_length
[]= {5, 3, 4};
617 const char *value
= "we the people";
618 size_t value_length
= strlen("we the people");
620 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
622 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
624 for (uint32_t x
= 0; x
< 3; x
++)
626 test_compare(MEMCACHED_SUCCESS
,
627 memcached_set(memc
, keys
[x
], key_length
[x
],
628 keys
[x
], key_length
[x
],
629 time_t(50), uint32_t(9)));
632 test_compare(MEMCACHED_SUCCESS
,
633 memcached_mget(memc
, keys
, key_length
, 3));
635 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
638 memcached_return_t rc
;
639 results
= memcached_fetch_result(memc
, results
, &rc
);
641 test_true(results
->item_cas
);
642 test_compare(MEMCACHED_SUCCESS
, rc
);
643 test_true(memcached_result_cas(results
));
645 test_memcmp(value
, "we the people", strlen("we the people"));
646 test_compare(strlen("we the people"), value_length
);
647 test_compare(MEMCACHED_SUCCESS
, rc
);
649 memcached_result_free(results
);
654 static test_return_t
cas_test(memcached_st
*memc
)
656 const char* keys
[2] = { __func__
, NULL
};
657 size_t keylengths
[2] = { strlen(__func__
), 0 };
659 memcached_result_st results_obj
;
661 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
663 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
665 test_compare(MEMCACHED_SUCCESS
,
667 test_literal_param(__func__
),
668 test_literal_param("we the people"),
669 (time_t)0, (uint32_t)0));
671 test_compare(MEMCACHED_SUCCESS
,
672 memcached_mget(memc
, keys
, keylengths
, 1));
674 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
677 memcached_return_t rc
;
678 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
680 test_compare(MEMCACHED_SUCCESS
, rc
);
681 test_true(memcached_result_cas(results
));
682 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
683 test_compare(test_literal_param_size("we the people"),
684 strlen(memcached_result_value(results
)));
686 uint64_t cas
= memcached_result_cas(results
);
689 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
690 test_true(rc
== MEMCACHED_END
);
691 test_true(results
== NULL
);
694 test_compare(MEMCACHED_SUCCESS
,
696 test_literal_param(__func__
),
697 test_literal_param("change the value"),
701 * The item will have a new cas value, so try to set it again with the old
702 * value. This should fail!
704 test_compare(MEMCACHED_DATA_EXISTS
,
706 test_literal_param(__func__
),
707 test_literal_param("change the value"),
710 memcached_result_free(&results_obj
);
715 static test_return_t
prepend_test(memcached_st
*memc
)
717 const char *key
= "fig";
718 const char *value
= "people";
720 test_compare(MEMCACHED_SUCCESS
,
721 memcached_flush(memc
, 0));
723 test_compare(MEMCACHED_SUCCESS
,
724 memcached_set(memc
, key
, strlen(key
),
725 value
, strlen(value
),
726 time_t(0), uint32_t(0)));
728 test_compare(MEMCACHED_SUCCESS
,
729 memcached_prepend(memc
, key
, strlen(key
),
730 "the ", strlen("the "),
731 time_t(0), uint32_t(0)));
733 test_compare(MEMCACHED_SUCCESS
,
734 memcached_prepend(memc
, key
, strlen(key
),
735 "we ", strlen("we "),
736 time_t(0), uint32_t(0)));
740 memcached_return_t rc
;
741 char *out_value
= memcached_get(memc
, key
, strlen(key
),
742 &value_length
, &flags
, &rc
);
743 test_memcmp(out_value
, "we the people", strlen("we the people"));
744 test_compare(strlen("we the people"), value_length
);
745 test_compare(MEMCACHED_SUCCESS
, rc
);
752 Set the value, then quit to make sure it is flushed.
753 Come back in and test that add fails.
755 static test_return_t
add_test(memcached_st
*memc
)
757 test_compare_hint(return_value_based_on_buffering(memc
),
759 test_literal_param(__func__
),
760 test_literal_param("when we sanitize"),
761 time_t(0), uint32_t(0)),
762 memcached_last_error_message(memc
));
764 memcached_quit(memc
);
766 test_compare_hint(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
768 test_literal_param(__func__
),
769 test_literal_param("try something else"),
770 time_t(0), uint32_t(0)),
771 memcached_last_error_message(memc
));
777 ** There was a problem of leaking filedescriptors in the initial release
778 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
779 ** systems it seems that the kernel is slow on reclaiming the resources
780 ** because the connects starts to time out (the test doesn't do much
781 ** anyway, so just loop 10 iterations)
783 static test_return_t
add_wrapper(memcached_st
*memc
)
785 unsigned int max
= 10000;
793 for (uint32_t x
= 0; x
< max
; x
++)
799 static test_return_t
replace_test(memcached_st
*memc
)
801 test_compare(return_value_based_on_buffering(memc
),
803 test_literal_param(__func__
),
804 test_literal_param("when we sanitize"),
805 time_t(0), uint32_t(0)));
807 test_compare(MEMCACHED_SUCCESS
,
808 memcached_replace(memc
,
809 test_literal_param(__func__
),
810 test_literal_param("first we insert some data"),
811 time_t(0), uint32_t(0)));
816 static test_return_t
delete_test(memcached_st
*memc
)
818 test_compare(return_value_based_on_buffering(memc
),
820 test_literal_param(__func__
),
821 test_literal_param("when we sanitize"),
822 time_t(0), uint32_t(0)));
824 test_compare_hint(return_value_based_on_buffering(memc
),
825 memcached_delete(memc
,
826 test_literal_param(__func__
),
828 memcached_last_error_message(memc
));
833 static test_return_t
flush_test(memcached_st
*memc
)
835 uint64_t query_id
= memcached_query_id(memc
);
836 test_compare(MEMCACHED_SUCCESS
,
837 memcached_flush(memc
, 0));
838 test_compare(query_id
+1, memcached_query_id(memc
));
843 static memcached_return_t
server_function(const memcached_st
*,
844 const memcached_server_st
*,
848 return MEMCACHED_SUCCESS
;
851 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
854 strncpy(context
, "foo bad", sizeof(context
));
855 memcached_server_fn callbacks
[1];
857 callbacks
[0]= server_function
;
858 memcached_server_cursor(memc
, callbacks
, context
, 1);
862 static test_return_t
bad_key_test(memcached_st
*memc
)
864 memcached_return_t rc
;
865 const char *key
= "foo bad";
868 uint64_t query_id
= memcached_query_id(memc
);
870 // Just skip if we are in binary mode.
871 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
873 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
875 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
876 test_true(memc_clone
);
878 query_id
= memcached_query_id(memc_clone
);
879 test_compare(MEMCACHED_SUCCESS
,
880 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
881 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
883 /* All keys are valid in the binary protocol (except for length) */
884 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
886 uint64_t before_query_id
= memcached_query_id(memc_clone
);
888 size_t string_length
;
889 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
890 &string_length
, &flags
, &rc
);
891 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
892 test_zero(string_length
);
895 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
897 query_id
= memcached_query_id(memc_clone
);
898 test_compare(MEMCACHED_SUCCESS
,
899 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
900 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
902 size_t string_length
;
903 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
904 &string_length
, &flags
, &rc
);
905 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
906 test_zero(string_length
);
910 /* Test multi key for bad keys */
911 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
912 size_t key_lengths
[] = { 7, 7, 7 };
913 query_id
= memcached_query_id(memc_clone
);
914 test_compare(MEMCACHED_SUCCESS
,
915 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
916 test_compare(query_id
, memcached_query_id(memc_clone
));
918 query_id
= memcached_query_id(memc_clone
);
919 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
920 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
921 test_compare(query_id
+1, memcached_query_id(memc_clone
));
923 query_id
= memcached_query_id(memc_clone
);
924 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
925 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
926 test_compare(query_id
+1, memcached_query_id(memc_clone
));
928 /* The following test should be moved to the end of this function when the
929 memcached server is updated to allow max size length of the keys in the
932 test_compare(MEMCACHED_SUCCESS
,
933 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
935 std::vector
<char> longkey
;
937 std::vector
<char>::iterator it
= longkey
.begin();
938 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
941 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
943 size_t string_length
;
945 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
946 test_compare(MEMCACHED_NOTFOUND
, rc
);
947 test_zero(string_length
);
949 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
950 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
951 test_zero(string_length
);
955 /* Make sure zero length keys are marked as bad */
957 test_compare(MEMCACHED_SUCCESS
,
958 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
959 size_t string_length
;
960 char *string
= memcached_get(memc_clone
, key
, 0,
961 &string_length
, &flags
, &rc
);
962 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
963 test_zero(string_length
);
967 memcached_free(memc_clone
);
972 #define READ_THROUGH_VALUE "set for me"
973 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
976 memcached_result_st
*result
)
978 (void)memc
;(void)key
;(void)key_length
;
979 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
982 #ifndef __INTEL_COMPILER
983 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
986 static test_return_t
read_through(memcached_st
*memc
)
988 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
990 size_t string_length
;
992 memcached_return_t rc
;
993 char *string
= memcached_get(memc
,
994 test_literal_param(__func__
),
995 &string_length
, &flags
, &rc
);
997 test_compare(MEMCACHED_NOTFOUND
, rc
);
998 test_false(string_length
);
1001 test_compare(MEMCACHED_SUCCESS
,
1002 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1004 string
= memcached_get(memc
,
1005 test_literal_param(__func__
),
1006 &string_length
, &flags
, &rc
);
1008 test_compare(MEMCACHED_SUCCESS
, rc
);
1009 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1010 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1011 test_strcmp(READ_THROUGH_VALUE
, string
);
1014 string
= memcached_get(memc
,
1015 test_literal_param(__func__
),
1016 &string_length
, &flags
, &rc
);
1018 test_compare(MEMCACHED_SUCCESS
, rc
);
1020 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1021 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1022 test_strcmp(READ_THROUGH_VALUE
, string
);
1025 return TEST_SUCCESS
;
1028 static test_return_t
get_test(memcached_st
*memc
)
1030 memcached_return_t rc
;
1032 size_t string_length
;
1035 uint64_t query_id
= memcached_query_id(memc
);
1036 rc
= memcached_delete(memc
,
1037 test_literal_param(__func__
),
1039 test_true_got(rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_NOTFOUND
, memcached_last_error_message(memc
));
1040 test_compare(query_id
+1, memcached_query_id(memc
));
1042 string
= memcached_get(memc
,
1043 test_literal_param(__func__
),
1044 &string_length
, &flags
, &rc
);
1046 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1047 test_false(string_length
);
1050 return TEST_SUCCESS
;
1053 static test_return_t
get_test2(memcached_st
*memc
)
1055 const char *value
= "when we sanitize";
1057 uint64_t query_id
= memcached_query_id(memc
);
1058 test_compare(return_value_based_on_buffering(memc
),
1060 test_literal_param(__func__
),
1061 value
, strlen(value
),
1062 time_t(0), uint32_t(0)));
1063 test_compare(query_id
+1, memcached_query_id(memc
));
1065 query_id
= memcached_query_id(memc
);
1066 test_true(query_id
);
1069 size_t string_length
;
1070 memcached_return_t rc
;
1071 char *string
= memcached_get(memc
,
1072 test_literal_param(__func__
),
1073 &string_length
, &flags
, &rc
);
1074 test_compare(query_id
+1, memcached_query_id(memc
));
1076 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1077 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1079 test_compare(strlen(value
), string_length
);
1080 test_memcmp(string
, value
, string_length
);
1084 return TEST_SUCCESS
;
1087 static test_return_t
set_test2(memcached_st
*memc
)
1089 for (uint32_t x
= 0; x
< 10; x
++)
1091 test_compare(return_value_based_on_buffering(memc
),
1093 test_literal_param("foo"),
1094 test_literal_param("train in the brain"),
1095 time_t(0), uint32_t(0)));
1098 return TEST_SUCCESS
;
1101 static test_return_t
set_test3(memcached_st
*memc
)
1103 size_t value_length
= 8191;
1105 std::vector
<char> value
;
1106 value
.reserve(value_length
);
1107 for (uint32_t x
= 0; x
< value_length
; x
++)
1109 value
.push_back(char(x
% 127));
1112 /* The dump test relies on there being at least 32 items in memcached */
1113 for (uint32_t x
= 0; x
< 32; x
++)
1117 snprintf(key
, sizeof(key
), "foo%u", x
);
1119 uint64_t query_id
= memcached_query_id(memc
);
1120 test_compare_hint(return_value_based_on_buffering(memc
),
1121 memcached_set(memc
, key
, strlen(key
),
1122 &value
[0], value
.size(),
1123 time_t(0), uint32_t(0)),
1124 memcached_last_error_message(memc
));
1125 test_compare(query_id
+1, memcached_query_id(memc
));
1128 return TEST_SUCCESS
;
1131 static test_return_t
get_test3(memcached_st
*memc
)
1133 size_t value_length
= 8191;
1135 std::vector
<char> value
;
1136 value
.reserve(value_length
);
1137 for (uint32_t x
= 0; x
< value_length
; x
++)
1139 value
.push_back(char(x
% 127));
1142 test_compare_hint(return_value_based_on_buffering(memc
),
1144 test_literal_param(__func__
),
1145 &value
[0], value
.size(),
1146 time_t(0), uint32_t(0)),
1147 memcached_last_error_message(memc
));
1149 size_t string_length
;
1151 memcached_return_t rc
;
1152 char *string
= memcached_get(memc
,
1153 test_literal_param(__func__
),
1154 &string_length
, &flags
, &rc
);
1156 test_compare(MEMCACHED_SUCCESS
, rc
);
1158 test_compare(value
.size(), string_length
);
1159 test_memcmp(string
, &value
[0], string_length
);
1163 return TEST_SUCCESS
;
1166 static test_return_t
get_test4(memcached_st
*memc
)
1168 size_t value_length
= 8191;
1170 std::vector
<char> value
;
1171 value
.reserve(value_length
);
1172 for (uint32_t x
= 0; x
< value_length
; x
++)
1174 value
.push_back(char(x
% 127));
1177 test_compare_hint(return_value_based_on_buffering(memc
),
1179 test_literal_param(__func__
),
1180 &value
[0], value
.size(),
1181 time_t(0), uint32_t(0)),
1182 memcached_last_error_message(memc
));
1184 for (uint32_t x
= 0; x
< 10; x
++)
1187 size_t string_length
;
1188 memcached_return_t rc
;
1189 char *string
= memcached_get(memc
,
1190 test_literal_param(__func__
),
1191 &string_length
, &flags
, &rc
);
1193 test_compare(MEMCACHED_SUCCESS
, rc
);
1195 test_compare(value
.size(), string_length
);
1196 test_memcmp(string
, &value
[0], string_length
);
1200 return TEST_SUCCESS
;
1204 * This test verifies that memcached_read_one_response doesn't try to
1205 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1206 * responses before you execute a storage command.
1208 static test_return_t
get_test5(memcached_st
*memc
)
1211 ** Request the same key twice, to ensure that we hash to the same server
1212 ** (so that we have multiple response values queued up) ;-)
1214 const char *keys
[]= { "key", "key" };
1215 size_t lengths
[]= { 3, 3 };
1219 test_compare_hint(return_value_based_on_buffering(memc
),
1220 memcached_set(memc
, keys
[0], lengths
[0],
1221 keys
[0], lengths
[0],
1222 time_t(0), uint32_t(0)),
1223 memcached_last_error_message(memc
));
1224 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1226 memcached_result_st results_obj
;
1227 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1230 memcached_return_t rc
;
1231 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1234 memcached_result_free(&results_obj
);
1236 /* Don't read out the second result, but issue a set instead.. */
1237 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1239 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1240 &rlen
, &flags
, &rc
);
1242 test_compare(MEMCACHED_NOTFOUND
, rc
);
1243 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1245 test_compare(MEMCACHED_SUCCESS
, rc
);
1248 return TEST_SUCCESS
;
1251 static test_return_t
mget_end(memcached_st
*memc
)
1253 const char *keys
[]= { "foo", "foo2" };
1254 size_t lengths
[]= { 3, 4 };
1255 const char *values
[]= { "fjord", "41" };
1258 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1260 test_compare(MEMCACHED_SUCCESS
,
1262 keys
[x
], lengths
[x
],
1263 values
[x
], strlen(values
[x
]),
1264 time_t(0), uint32_t(0)));
1268 size_t string_length
;
1271 // retrieve both via mget
1272 test_compare(MEMCACHED_SUCCESS
,
1273 memcached_mget(memc
,
1275 test_array_length(keys
)));
1277 char key
[MEMCACHED_MAX_KEY
];
1279 memcached_return_t rc
;
1281 // this should get both
1282 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1284 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1286 test_compare(MEMCACHED_SUCCESS
, rc
);
1288 if (key_length
== 4)
1293 test_compare(string_length
, strlen(values
[val
]));
1294 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1298 // this should indicate end
1299 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1300 test_compare(MEMCACHED_END
, rc
);
1304 test_compare(MEMCACHED_SUCCESS
,
1305 memcached_mget(memc
, keys
, lengths
, 1));
1307 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1308 test_compare(key_length
, lengths
[0]);
1309 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1310 test_compare(string_length
, strlen(values
[0]));
1311 test_true(strncmp(values
[0], string
, string_length
) == 0);
1312 test_compare(MEMCACHED_SUCCESS
, rc
);
1315 // this should indicate end
1316 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1317 test_compare(MEMCACHED_END
, rc
);
1320 return TEST_SUCCESS
;
1323 /* Do not copy the style of this code, I just access hosts to testthis function */
1324 static test_return_t
stats_servername_test(memcached_st
*memc
)
1326 memcached_stat_st memc_stat
;
1327 memcached_server_instance_st instance
=
1328 memcached_server_instance_by_position(memc
, 0);
1330 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1332 return TEST_SKIPPED
;
1335 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1336 memcached_server_name(instance
),
1337 memcached_server_port(instance
)));
1339 return TEST_SUCCESS
;
1342 static test_return_t
increment_test(memcached_st
*memc
)
1344 uint64_t new_number
;
1346 test_compare(MEMCACHED_SUCCESS
,
1348 test_literal_param("number"),
1349 test_literal_param("0"),
1350 (time_t)0, (uint32_t)0));
1352 test_compare(MEMCACHED_SUCCESS
,
1353 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1354 test_compare(uint64_t(1), new_number
);
1356 test_compare(MEMCACHED_SUCCESS
,
1357 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1358 test_compare(uint64_t(2), new_number
);
1360 return TEST_SUCCESS
;
1363 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1365 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1367 uint64_t new_number
;
1368 uint64_t initial
= 0;
1370 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1372 test_compare(MEMCACHED_SUCCESS
,
1373 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1374 test_compare(new_number
, initial
);
1376 test_compare(MEMCACHED_SUCCESS
,
1377 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1378 test_compare(new_number
, (initial
+1));
1380 return TEST_SUCCESS
;
1383 static test_return_t
decrement_test(memcached_st
*memc
)
1385 test_compare(return_value_based_on_buffering(memc
),
1387 test_literal_param(__func__
),
1388 test_literal_param("3"),
1389 time_t(0), uint32_t(0)));
1390 // Make sure we flush the value we just set
1391 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1393 uint64_t new_number
;
1394 test_compare(MEMCACHED_SUCCESS
,
1395 memcached_decrement(memc
,
1396 test_literal_param(__func__
),
1398 test_compare(uint64_t(2), new_number
);
1400 test_compare(MEMCACHED_SUCCESS
,
1401 memcached_decrement(memc
,
1402 test_literal_param(__func__
),
1404 test_compare(uint64_t(1), new_number
);
1406 return TEST_SUCCESS
;
1409 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1411 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1413 uint64_t initial
= 3;
1415 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1417 uint64_t new_number
;
1418 test_compare(MEMCACHED_SUCCESS
,
1419 memcached_decrement_with_initial(memc
,
1420 test_literal_param(__func__
),
1423 test_compare(new_number
, initial
);
1425 test_compare(MEMCACHED_SUCCESS
,
1426 memcached_decrement_with_initial(memc
,
1427 test_literal_param(__func__
),
1430 test_compare(new_number
, (initial
- 1));
1432 return TEST_SUCCESS
;
1435 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1437 const char *master_key
= "foo";
1438 const char *key
= "number";
1439 const char *value
= "0";
1441 test_compare(return_value_based_on_buffering(memc
),
1442 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1444 value
, strlen(value
),
1445 time_t(0), uint32_t(0)));
1447 // Make sure we flush the value we just set
1448 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1450 uint64_t new_number
;
1451 test_compare(MEMCACHED_SUCCESS
,
1452 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1453 key
, strlen(key
), 1, &new_number
));
1454 test_compare(uint64_t(1), new_number
);
1456 test_compare(MEMCACHED_SUCCESS
,
1457 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1458 key
, strlen(key
), 1, &new_number
));
1459 test_compare(uint64_t(2), new_number
);
1461 return TEST_SUCCESS
;
1464 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1466 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1468 uint64_t new_number
;
1469 const char *master_key
= "foo";
1470 const char *key
= "number";
1471 uint64_t initial
= 0;
1473 test_compare(MEMCACHED_SUCCESS
,
1474 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1476 1, initial
, 0, &new_number
));
1477 test_compare(new_number
, initial
);
1479 test_compare(MEMCACHED_SUCCESS
,
1480 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1482 1, initial
, 0, &new_number
));
1483 test_compare(new_number
, (initial
+1));
1485 return TEST_SUCCESS
;
1488 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1490 uint64_t new_number
;
1491 const char *value
= "3";
1493 test_compare(return_value_based_on_buffering(memc
),
1494 memcached_set_by_key(memc
,
1495 test_literal_param("foo"),
1496 test_literal_param("number"),
1497 value
, strlen(value
),
1498 (time_t)0, (uint32_t)0));
1500 test_compare(MEMCACHED_SUCCESS
,
1501 memcached_decrement_by_key(memc
,
1502 test_literal_param("foo"),
1503 test_literal_param("number"),
1505 test_compare(uint64_t(2), new_number
);
1507 test_compare(MEMCACHED_SUCCESS
,
1508 memcached_decrement_by_key(memc
,
1509 test_literal_param("foo"),
1510 test_literal_param("number"),
1512 test_compare(uint64_t(1), new_number
);
1514 return TEST_SUCCESS
;
1517 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1519 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1521 uint64_t new_number
;
1522 uint64_t initial
= 3;
1524 test_compare(MEMCACHED_SUCCESS
,
1525 memcached_decrement_with_initial_by_key(memc
,
1526 test_literal_param("foo"),
1527 test_literal_param("number"),
1528 1, initial
, 0, &new_number
));
1529 test_compare(new_number
, initial
);
1531 test_compare(MEMCACHED_SUCCESS
,
1532 memcached_decrement_with_initial_by_key(memc
,
1533 test_literal_param("foo"),
1534 test_literal_param("number"),
1535 1, initial
, 0, &new_number
));
1536 test_compare(new_number
, (initial
- 1));
1538 return TEST_SUCCESS
;
1540 static test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1542 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1544 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1546 test_compare(return_value_based_on_buffering(memc
),
1548 test_literal_param("number"),
1549 test_literal_param("0"),
1550 (time_t)0, (uint32_t)0));
1552 uint64_t new_number
;
1553 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1554 test_literal_param("number"),
1556 test_compare(uint64_t(1), new_number
);
1558 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1559 test_literal_param("number"),
1561 test_compare(uint64_t(2), new_number
);
1563 return TEST_SUCCESS
;
1566 static test_return_t
quit_test(memcached_st
*memc
)
1568 const char *value
= "sanford and sun";
1570 test_compare(return_value_based_on_buffering(memc
),
1572 test_literal_param(__func__
),
1573 value
, strlen(value
),
1574 (time_t)10, (uint32_t)3));
1575 memcached_quit(memc
);
1577 test_compare(return_value_based_on_buffering(memc
),
1579 test_literal_param(__func__
),
1580 value
, strlen(value
),
1581 (time_t)50, (uint32_t)9));
1583 return TEST_SUCCESS
;
1586 static test_return_t
mget_result_test(memcached_st
*memc
)
1588 const char *keys
[]= {"fudge", "son", "food"};
1589 size_t key_length
[]= {5, 3, 4};
1591 memcached_result_st results_obj
;
1592 memcached_result_st
*results
;
1594 results
= memcached_result_create(memc
, &results_obj
);
1596 test_true(&results_obj
== results
);
1598 /* We need to empty the server before continueing test */
1599 test_compare(MEMCACHED_SUCCESS
,
1600 memcached_flush(memc
, 0));
1602 test_compare(MEMCACHED_SUCCESS
,
1603 memcached_mget(memc
, keys
, key_length
, 3));
1605 memcached_return_t rc
;
1606 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1611 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1612 test_false(results
);
1613 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1615 for (uint32_t x
= 0; x
< 3; x
++)
1617 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1618 keys
[x
], key_length
[x
],
1619 (time_t)50, (uint32_t)9);
1620 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1623 test_compare(MEMCACHED_SUCCESS
,
1624 memcached_mget(memc
, keys
, key_length
, 3));
1626 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1629 test_true(&results_obj
== results
);
1630 test_compare(MEMCACHED_SUCCESS
, rc
);
1631 test_memcmp(memcached_result_key_value(results
),
1632 memcached_result_value(results
),
1633 memcached_result_length(results
));
1634 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1637 memcached_result_free(&results_obj
);
1639 return TEST_SUCCESS
;
1642 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1644 const char *keys
[]= {"fudge", "son", "food"};
1645 size_t key_length
[]= {5, 3, 4};
1647 memcached_result_st
*results
;
1649 /* We need to empty the server before continueing test */
1650 test_compare(MEMCACHED_SUCCESS
,
1651 memcached_flush(memc
, 0));
1653 test_compare(MEMCACHED_SUCCESS
,
1654 memcached_mget(memc
, keys
, key_length
, 3));
1656 memcached_return_t rc
;
1657 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1661 test_false(results
);
1662 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1664 for (uint32_t x
= 0; x
< 3; x
++)
1666 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1667 keys
[x
], key_length
[x
],
1668 (time_t)50, (uint32_t)9);
1669 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1672 test_compare(MEMCACHED_SUCCESS
,
1673 memcached_mget(memc
, keys
, key_length
, 3));
1676 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1679 test_compare(MEMCACHED_SUCCESS
, rc
);
1680 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1681 test_memcmp(memcached_result_key_value(results
),
1682 memcached_result_value(results
),
1683 memcached_result_length(results
));
1684 memcached_result_free(results
);
1688 return TEST_SUCCESS
;
1691 /* Count the results */
1692 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1694 size_t *counter
= (size_t *)context
;
1696 *counter
= *counter
+ 1;
1698 return MEMCACHED_SUCCESS
;
1701 static test_return_t
mget_result_function(memcached_st
*memc
)
1703 const char *keys
[]= {"fudge", "son", "food"};
1704 size_t key_length
[]= {5, 3, 4};
1706 memcached_execute_fn callbacks
[1];
1708 for (uint32_t x
= 0; x
< 3; x
++)
1710 test_compare(return_value_based_on_buffering(memc
),
1711 memcached_set(memc
, keys
[x
], key_length
[x
],
1712 keys
[x
], key_length
[x
],
1713 time_t(50), uint32_t(9)));
1715 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1716 memcached_quit(memc
);
1718 test_compare(MEMCACHED_SUCCESS
,
1719 memcached_mget(memc
, keys
, key_length
, 3));
1721 callbacks
[0]= &callback_counter
;
1724 test_compare(MEMCACHED_SUCCESS
,
1725 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1727 test_compare(size_t(3), counter
);
1729 return TEST_SUCCESS
;
1732 static test_return_t
mget_test(memcached_st
*memc
)
1734 const char *keys
[]= {"fudge", "son", "food"};
1735 size_t key_length
[]= {5, 3, 4};
1737 char return_key
[MEMCACHED_MAX_KEY
];
1738 size_t return_key_length
;
1740 size_t return_value_length
;
1742 test_compare(MEMCACHED_SUCCESS
,
1743 memcached_mget(memc
, keys
, key_length
, 3));
1746 memcached_return_t rc
;
1747 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1748 &return_value_length
, &flags
, &rc
)))
1750 test_true(return_value
);
1752 test_false(return_value
);
1753 test_zero(return_value_length
);
1754 test_compare(MEMCACHED_NOTFOUND
, rc
);
1756 for (uint32_t x
= 0; x
< 3; x
++)
1758 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1759 keys
[x
], key_length
[x
],
1760 (time_t)50, (uint32_t)9);
1761 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1763 test_compare(MEMCACHED_SUCCESS
,
1764 memcached_mget(memc
, keys
, key_length
, 3));
1767 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1768 &return_value_length
, &flags
, &rc
)))
1770 test_true(return_value
);
1771 test_compare(MEMCACHED_SUCCESS
, rc
);
1772 if (not memc
->_namespace
)
1774 test_compare(return_key_length
, return_value_length
);
1775 test_memcmp(return_value
, return_key
, return_value_length
);
1781 return TEST_SUCCESS
;
1784 static test_return_t
mget_execute(memcached_st
*original_memc
)
1786 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1788 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1791 size_t max_keys
= 20480;
1794 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1795 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1797 /* First add all of the items.. */
1798 char blob
[1024] = {0};
1800 for (size_t x
= 0; x
< max_keys
; ++x
)
1804 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1806 test_true(keys
[x
] != NULL
);
1807 uint64_t query_id
= memcached_query_id(memc
);
1808 memcached_return_t rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1809 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1810 test_compare(query_id
+1, memcached_query_id(memc
));
1813 /* Try to get all of them with a large multiget */
1815 memcached_execute_fn callbacks
[]= { &callback_counter
};
1816 test_compare(MEMCACHED_SUCCESS
,
1817 memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1818 max_keys
, callbacks
, &counter
, 1));
1821 uint64_t query_id
= memcached_query_id(memc
);
1822 test_compare(MEMCACHED_SUCCESS
,
1823 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1824 test_compare(query_id
, memcached_query_id(memc
));
1826 /* Verify that we got all of the items */
1827 test_true(counter
== max_keys
);
1830 /* Release all allocated resources */
1831 for (size_t x
= 0; x
< max_keys
; ++x
)
1838 memcached_free(memc
);
1840 return TEST_SUCCESS
;
1843 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1845 static test_return_t
key_setup(memcached_st
*memc
)
1847 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1849 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1851 return TEST_SUCCESS
;
1854 static test_return_t
key_teardown(memcached_st
*memc
)
1857 pairs_free(global_pairs
);
1859 return TEST_SUCCESS
;
1862 static test_return_t
block_add_regression(memcached_st
*memc
)
1864 /* First add all of the items.. */
1865 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1867 char blob
[1024] = {0};
1869 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);
1870 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
, memcached_strerror(NULL
, rc
));
1873 return TEST_SUCCESS
;
1876 static test_return_t
binary_add_regression(memcached_st
*memc
)
1878 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1879 test_return_t rc
= block_add_regression(memc
);
1884 static test_return_t
get_stats_keys(memcached_st
*memc
)
1888 memcached_stat_st memc_stat
;
1889 memcached_return_t rc
;
1891 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1892 test_compare(MEMCACHED_SUCCESS
, rc
);
1893 for (ptr
= stat_list
; *ptr
; ptr
++)
1898 return TEST_SUCCESS
;
1901 static test_return_t
version_string_test(memcached_st
*)
1903 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1905 return TEST_SUCCESS
;
1908 static test_return_t
get_stats(memcached_st
*memc
)
1910 memcached_return_t rc
;
1912 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1913 test_compare(MEMCACHED_SUCCESS
, rc
);
1914 test_true(memc_stat
);
1916 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1918 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1919 test_compare(MEMCACHED_SUCCESS
, rc
);
1920 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1925 memcached_stat_free(NULL
, memc_stat
);
1927 return TEST_SUCCESS
;
1930 static test_return_t
add_host_test(memcached_st
*memc
)
1932 char servername
[]= "0.example.com";
1934 memcached_return_t rc
;
1935 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1936 test_compare(1U, memcached_server_list_count(servers
));
1938 for (unsigned int x
= 2; x
< 20; x
++)
1940 char buffer
[SMALL_STRING_LEN
];
1942 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1943 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1945 test_compare(MEMCACHED_SUCCESS
, rc
);
1946 test_compare(x
, memcached_server_list_count(servers
));
1949 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1950 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1952 memcached_server_list_free(servers
);
1954 return TEST_SUCCESS
;
1957 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1959 memcached_return_t rc
;
1961 const char *key
= "not_found";
1962 size_t key_length
= test_literal_param_size("not_found");
1964 test_compare(MEMCACHED_SUCCESS
,
1965 memcached_mget(memc
, &key
, &key_length
, 1));
1967 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1969 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1971 memcached_result_free(result
);
1973 return TEST_SUCCESS
;
1976 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1978 return MEMCACHED_SUCCESS
;
1981 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1983 return MEMCACHED_SUCCESS
;
1986 static test_return_t
callback_test(memcached_st
*memc
)
1988 /* Test User Data */
1992 memcached_return_t rc
;
1994 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1995 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1996 test_true(*test_ptr
== x
);
1999 /* Test Clone Callback */
2001 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2002 void *clone_cb_ptr
= *(void **)&clone_cb
;
2003 void *temp_function
= NULL
;
2005 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
2006 memcached_return_t rc
;
2007 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2008 test_true(temp_function
== clone_cb_ptr
);
2009 test_compare(MEMCACHED_SUCCESS
, rc
);
2012 /* Test Cleanup Callback */
2014 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2015 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2016 void *temp_function
= NULL
;
2017 memcached_return_t rc
;
2019 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2020 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2021 test_true(temp_function
== cleanup_cb_ptr
);
2024 return TEST_SUCCESS
;
2027 /* We don't test the behavior itself, we test the switches */
2028 static test_return_t
behavior_test(memcached_st
*memc
)
2030 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2031 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2033 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2034 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2036 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2037 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2039 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2040 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2042 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2043 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2045 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2046 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2048 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2049 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2051 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2053 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2055 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2056 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2057 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2059 return TEST_SUCCESS
;
2062 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2064 test_compare(MEMCACHED_DEPRECATED
,
2065 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2067 // Platform dependent
2069 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2073 return TEST_SUCCESS
;
2077 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2079 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2080 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2082 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2084 if (memcached_success(rc
))
2093 return TEST_SUCCESS
;
2097 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2099 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2100 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2102 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2104 if (memcached_success(rc
))
2113 return TEST_SUCCESS
;
2116 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, memcached_return_t
& rc
)
2120 memcached_result_st
* result
= NULL
;
2121 while ((result
= memcached_fetch_result(memc
, result
, &rc
)))
2123 test_compare(MEMCACHED_SUCCESS
, rc
);
2126 memcached_result_free(result
);
2128 return TEST_SUCCESS
;
2131 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
)
2133 memcached_return_t rc
;
2134 return fetch_all_results(memc
, keys_returned
, rc
);
2137 /* Test case provided by Cal Haldenbrand */
2138 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2139 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2140 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2142 /* We just keep looking at the same values over and over */
2145 test_compare(MEMCACHED_SUCCESS
,
2146 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2147 test_compare(MEMCACHED_SUCCESS
,
2148 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2152 unsigned long long total
= 0;
2153 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2155 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2156 char randomstuff
[6 * 1024];
2157 memset(randomstuff
, 0, 6 * 1024);
2158 test_true(size
< 6 * 1024); /* Being safe here */
2160 for (uint32_t j
= 0 ; j
< size
;j
++)
2162 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2166 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2167 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2168 test_compare(MEMCACHED_SUCCESS
,
2169 memcached_set(memc
, key
, key_length
,
2170 randomstuff
, strlen(randomstuff
),
2171 time_t(0), HALDENBRAND_FLAG_KEY
));
2173 test_true(total
> HALDENBRAND_KEY_COUNT
);
2175 return TEST_SUCCESS
;
2178 /* Test case provided by Cal Haldenbrand */
2179 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2181 test_compare(MEMCACHED_SUCCESS
,
2182 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2184 test_compare(MEMCACHED_SUCCESS
,
2185 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2188 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576));
2189 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576));
2190 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2191 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2193 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2196 size_t total_value_length
= 0;
2197 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2202 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2203 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2205 memcached_return_t rc
;
2206 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2207 if (memcached_failed(rc
))
2209 if (rc
== MEMCACHED_NOTFOUND
)
2220 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2223 total_value_length
+= val_len
;
2228 return TEST_SUCCESS
;
2231 /* Do a large mget() over all the keys we think exist */
2232 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2234 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2235 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2238 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576);
2239 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576);
2240 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2241 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2244 std::vector
<size_t> key_lengths
;
2245 key_lengths
.resize(HALDENBRAND_KEY_COUNT
);
2246 std::vector
<char *> keys
;
2247 keys
.resize(key_lengths
.size());
2248 for (uint32_t x
= 0; x
< key_lengths
.size(); x
++)
2250 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2251 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2252 test_true(key_length
> 0 and key_length
< MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1);
2253 keys
[x
]= strdup(key
);
2254 key_lengths
[x
]= key_length
;
2257 test_compare(MEMCACHED_SUCCESS
,
2258 memcached_mget(memc
, &keys
[0], &key_lengths
[0], key_lengths
.size()));
2260 unsigned int keys_returned
;
2261 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
));
2262 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2264 for (std::vector
<char *>::iterator iter
= keys
.begin();
2271 return TEST_SUCCESS
;
2274 /* Make sure we behave properly if server list has no values */
2275 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2277 const char *keys
[]= {"fudge", "son", "food"};
2278 size_t key_length
[]= {5, 3, 4};
2280 /* Here we free everything before running a bunch of mget tests */
2281 memcached_servers_reset(memc
);
2284 /* We need to empty the server before continueing test */
2285 test_compare(MEMCACHED_NO_SERVERS
,
2286 memcached_flush(memc
, 0));
2288 test_compare(MEMCACHED_NO_SERVERS
,
2289 memcached_mget(memc
, keys
, key_length
, 3));
2292 unsigned int keys_returned
;
2293 memcached_return_t rc
;
2294 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2295 test_compare(MEMCACHED_NOTFOUND
, rc
);
2296 test_zero(keys_returned
);
2299 for (uint32_t x
= 0; x
< 3; x
++)
2301 test_compare(MEMCACHED_NO_SERVERS
,
2302 memcached_set(memc
, keys
[x
], key_length
[x
],
2303 keys
[x
], key_length
[x
],
2304 (time_t)50, (uint32_t)9));
2307 test_compare(MEMCACHED_NO_SERVERS
,
2308 memcached_mget(memc
, keys
, key_length
, 3));
2312 char return_key
[MEMCACHED_MAX_KEY
];
2313 memcached_return_t rc
;
2314 size_t return_key_length
;
2315 size_t return_value_length
;
2318 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2319 &return_value_length
, &flags
, &rc
)))
2321 test_true(return_value
);
2322 test_compare(MEMCACHED_SUCCESS
, rc
);
2323 test_true(return_key_length
== return_value_length
);
2324 test_memcmp(return_value
, return_key
, return_value_length
);
2330 return TEST_SUCCESS
;
2333 #define VALUE_SIZE_BUG5 1048064
2334 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2336 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2337 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2339 size_t value_length
;
2341 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2343 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2345 insert_data
[x
]= (signed char)rand();
2348 test_compare(MEMCACHED_SUCCESS
,
2349 memcached_flush(memc
, 0));
2351 memcached_return_t rc
;
2352 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2353 test_compare(MEMCACHED_SUCCESS
,
2354 memcached_mget(memc
, keys
, key_length
, 4));
2357 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2358 test_compare(MEMCACHED_NOTFOUND
, rc
);
2361 for (uint32_t x
= 0; x
< 4; x
++)
2363 test_compare(MEMCACHED_SUCCESS
,
2364 memcached_set(memc
, keys
[x
], key_length
[x
],
2365 insert_data
, VALUE_SIZE_BUG5
,
2366 (time_t)0, (uint32_t)0));
2369 for (uint32_t x
= 0; x
< 10; x
++)
2371 value
= memcached_get(memc
, keys
[0], key_length
[0],
2372 &value_length
, &flags
, &rc
);
2373 test_compare(rc
, MEMCACHED_SUCCESS
);
2377 test_compare(MEMCACHED_SUCCESS
,
2378 memcached_mget(memc
, keys
, key_length
, 4));
2380 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2381 test_compare(4U, count
);
2383 delete [] insert_data
;
2385 return TEST_SUCCESS
;
2388 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2390 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2391 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2392 char return_key
[MEMCACHED_MAX_KEY
];
2393 size_t return_key_length
;
2395 size_t value_length
;
2397 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2399 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2401 insert_data
[x
]= (signed char)rand();
2404 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2406 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2408 // We will now confirm that memcached_mget() returns success, but we will
2409 // then check to make sure that no actual keys are returned.
2410 test_compare(MEMCACHED_SUCCESS
,
2411 memcached_mget(memc
, keys
, key_length
, 4));
2413 memcached_return_t rc
;
2415 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2416 &value_length
, &flags
, &rc
)))
2421 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2423 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2425 test_compare(MEMCACHED_SUCCESS
,
2426 memcached_set(memc
, keys
[x
], key_length
[x
],
2427 insert_data
, VALUE_SIZE_BUG5
,
2428 (time_t)0, (uint32_t)0));
2430 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2432 for (uint32_t x
= 0; x
< 2; x
++)
2434 value
= memcached_get(memc
, keys
[0], key_length
[0],
2435 &value_length
, &flags
, &rc
);
2439 test_compare(MEMCACHED_SUCCESS
,
2440 memcached_mget(memc
, keys
, key_length
, 4));
2441 /* We test for purge of partial complete fetches */
2442 for (count
= 3; count
; count
--)
2444 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2445 &value_length
, &flags
, &rc
);
2446 test_compare(MEMCACHED_SUCCESS
, rc
);
2447 test_memcmp(value
, insert_data
, value_length
);
2448 test_true(value_length
);
2452 delete [] insert_data
;
2454 return TEST_SUCCESS
;
2457 static test_return_t
user_supplied_bug8(memcached_st
*)
2459 memcached_return_t rc
;
2461 memcached_st
*memc_clone
;
2463 memcached_server_st
*servers
;
2464 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";
2466 servers
= memcached_servers_parse(server_list
);
2469 mine
= memcached_create(NULL
);
2470 rc
= memcached_server_push(mine
, servers
);
2471 test_compare(MEMCACHED_SUCCESS
, rc
);
2472 memcached_server_list_free(servers
);
2475 memc_clone
= memcached_clone(NULL
, mine
);
2477 memcached_quit(mine
);
2478 memcached_quit(memc_clone
);
2481 memcached_free(mine
);
2482 memcached_free(memc_clone
);
2484 return TEST_SUCCESS
;
2487 /* Test flag store/retrieve */
2488 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2490 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2491 test_true(insert_data
);
2493 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2495 insert_data
[x
]= (signed char)rand();
2498 memcached_flush(memc
, 0);
2500 const char *keys
= "036790384900";
2501 size_t key_length
= strlen(keys
);
2502 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2503 insert_data
, VALUE_SIZE_BUG5
,
2505 memcached_last_error_message(memc
));
2507 memcached_return_t rc
;
2508 size_t value_length
;
2510 char *value
= memcached_get(memc
, keys
, key_length
,
2511 &value_length
, &flags
, &rc
);
2512 test_compare(245U, flags
);
2516 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2518 char return_key
[MEMCACHED_MAX_KEY
];
2519 size_t return_key_length
;
2521 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2522 &value_length
, &flags
, &rc
);
2523 test_compare(uint32_t(245), flags
);
2526 delete [] insert_data
;
2529 return TEST_SUCCESS
;
2532 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2534 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2535 size_t key_length
[3];
2539 char return_key
[MEMCACHED_MAX_KEY
];
2540 size_t return_key_length
;
2542 size_t return_value_length
;
2545 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2546 key_length
[1]= strlen("fudge&*@#");
2547 key_length
[2]= strlen("for^#@&$not");
2550 for (unsigned int x
= 0; x
< 3; x
++)
2552 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2553 keys
[x
], key_length
[x
],
2554 (time_t)50, (uint32_t)9);
2555 test_compare(MEMCACHED_SUCCESS
, rc
);
2558 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2559 test_compare(MEMCACHED_SUCCESS
, rc
);
2561 /* We need to empty the server before continueing test */
2562 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2563 &return_value_length
, &flags
, &rc
)) != NULL
)
2565 test_true(return_value
);
2569 test_compare(3U, count
);
2571 return TEST_SUCCESS
;
2574 /* We are testing with aggressive timeout to get failures */
2575 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2577 size_t value_length
= 512;
2578 unsigned int set
= 1;
2579 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2581 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2582 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2583 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2585 std::vector
<char> value
;
2586 value
.reserve(value_length
);
2587 for (uint32_t x
= 0; x
< value_length
; x
++)
2589 value
.push_back(char(x
% 127));
2592 for (unsigned int x
= 1; x
<= 100000; ++x
)
2594 memcached_return_t rc
= memcached_set(mclone
,
2595 test_literal_param("foo"),
2596 &value
[0], value
.size(),
2599 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2600 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2601 memcached_strerror(NULL
, rc
));
2603 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2609 memcached_free(mclone
);
2611 return TEST_SUCCESS
;
2615 We are looking failures in the async protocol
2617 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2619 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2621 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2622 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2623 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2625 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2628 std::vector
<char> value
;
2630 for (unsigned int x
= 0; x
< 512; x
++)
2632 value
.push_back(char(x
% 127));
2635 for (unsigned int x
= 1; x
<= 100000; ++x
)
2637 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2641 memcached_free(mclone
);
2643 return TEST_SUCCESS
;
2647 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2649 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2651 memcached_return_t rc
;
2653 size_t value_length
;
2655 uint64_t number_value
;
2657 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2658 &value_length
, &flags
, &rc
);
2660 test_compare(MEMCACHED_NOTFOUND
, rc
);
2662 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2665 /* The binary protocol will set the key if it doesn't exist */
2666 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2668 test_compare(MEMCACHED_SUCCESS
, rc
);
2672 test_compare(MEMCACHED_NOTFOUND
, rc
);
2675 test_compare(MEMCACHED_SUCCESS
,
2676 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2678 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2682 test_compare(MEMCACHED_SUCCESS
,
2683 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2684 test_compare(2UL, number_value
);
2686 return TEST_SUCCESS
;
2690 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2691 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2693 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2695 char key
[] = "key34567890";
2696 memcached_return_t rc
;
2697 size_t overflowSize
;
2699 char commandFirst
[]= "set key34567890 0 0 ";
2700 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2701 size_t commandLength
;
2704 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2706 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2708 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2710 char *overflow
= new (std::nothrow
) char[testSize
];
2711 test_true(overflow
);
2713 memset(overflow
, 'x', testSize
);
2714 rc
= memcached_set(memc
, key
, strlen(key
),
2715 overflow
, testSize
, 0, 0);
2716 test_compare(MEMCACHED_SUCCESS
, rc
);
2720 return TEST_SUCCESS
;
2725 Test values of many different sizes
2726 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2727 set key34567890 0 0 8169 \r\n
2728 is sent followed by buffer of size 8169, followed by 8169
2730 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2732 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2734 std::vector
<char> value
;
2735 value
.reserve(18000);
2736 for (size_t x
= 0; x
< 18000; x
++)
2738 value
.push_back((char) (x
% 127));
2741 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2743 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2744 &value
[0], current_length
,
2745 (time_t)0, (uint32_t)0);
2746 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2748 size_t string_length
;
2750 char *string
= memcached_get(memc
, test_literal_param("foo"),
2751 &string_length
, &flags
, &rc
);
2753 test_compare(MEMCACHED_SUCCESS
, rc
);
2754 test_compare(string_length
, current_length
);
2755 test_memcmp(string
, &value
[0], string_length
);
2760 return TEST_SUCCESS
;
2764 Look for zero length value problems
2766 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2768 for (uint32_t x
= 0; x
< 2; x
++)
2770 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2772 (time_t)0, (uint32_t)0);
2774 test_compare(MEMCACHED_SUCCESS
, rc
);
2778 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2779 &length
, &flags
, &rc
);
2781 test_compare(MEMCACHED_SUCCESS
, rc
);
2786 value
= memcached_get(memc
, test_literal_param("mykey"),
2787 &length
, &flags
, &rc
);
2789 test_compare(MEMCACHED_SUCCESS
, rc
);
2790 test_true(value
== NULL
);
2795 return TEST_SUCCESS
;
2798 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2799 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2801 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2803 (time_t)0, UINT32_MAX
),
2804 memcached_last_error_message(memc
));
2809 memcached_return_t rc
;
2810 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2811 &length
, &flags
, &rc
);
2813 test_compare(MEMCACHED_SUCCESS
, rc
);
2816 test_compare(flags
, UINT32_MAX
);
2818 return TEST_SUCCESS
;
2821 #if !defined(__sun) && !defined(__OpenBSD__)
2822 /* Check the validity of chinese key*/
2823 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2825 const char *key
= "豆瓣";
2826 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2827 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2828 value
, strlen(value
),
2831 test_compare(MEMCACHED_SUCCESS
, rc
);
2835 char *value2
= memcached_get(memc
, key
, strlen(key
),
2836 &length
, &flags
, &rc
);
2838 test_true(length
==strlen(value
));
2839 test_compare(MEMCACHED_SUCCESS
, rc
);
2840 test_memcmp(value
, value2
, length
);
2843 return TEST_SUCCESS
;
2851 static test_return_t
user_supplied_bug19(memcached_st
*)
2853 memcached_return_t res
;
2855 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2857 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2860 memcached_free(memc
);
2862 return TEST_SUCCESS
;
2865 /* CAS test from Andei */
2866 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2868 const char *key
= "abc";
2869 size_t key_len
= strlen("abc");
2871 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2873 test_compare(MEMCACHED_SUCCESS
,
2875 test_literal_param("abc"),
2876 test_literal_param("foobar"),
2877 (time_t)0, (uint32_t)0));
2879 test_compare(MEMCACHED_SUCCESS
,
2880 memcached_mget(memc
, &key
, &key_len
, 1));
2882 memcached_result_st result_obj
;
2883 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2886 memcached_result_create(memc
, &result_obj
);
2887 memcached_return_t status
;
2888 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2891 test_compare(MEMCACHED_SUCCESS
, status
);
2893 memcached_result_free(result
);
2895 return TEST_SUCCESS
;
2898 /* Large mget() of missing keys with binary proto
2900 * If many binary quiet commands (such as getq's in an mget) fill the output
2901 * buffer and the server chooses not to respond, memcached_flush hangs. See
2902 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2905 /* sighandler_t function that always asserts false */
2906 static void fail(int)
2912 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2917 return TEST_SKIPPED
;
2919 void (*oldalarm
)(int);
2921 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2922 test_true(memc_clone
);
2924 /* only binproto uses getq for mget */
2925 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2927 /* empty the cache to ensure misses (hence non-responses) */
2928 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2930 std::vector
<size_t> key_lengths
;
2931 key_lengths
.resize(key_count
);
2932 std::vector
<char *> keys
;
2933 keys
.resize(key_lengths
.size());
2934 for (unsigned int x
= 0; x
< key_lengths
.size(); x
++)
2936 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2937 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2938 test_true(key_length
> 0 and key_length
< MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1);
2939 keys
[x
]= strdup(key
);
2940 key_lengths
[x
]= key_length
;
2943 oldalarm
= signal(SIGALRM
, fail
);
2946 test_compare_got(MEMCACHED_SUCCESS
,
2947 memcached_mget(memc_clone
, &keys
[0], &key_lengths
[0], key_count
), memcached_last_error_message(memc_clone
));
2950 signal(SIGALRM
, oldalarm
);
2952 memcached_return_t rc
;
2954 char return_key
[MEMCACHED_MAX_KEY
];
2955 size_t return_key_length
;
2957 size_t return_value_length
;
2958 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2959 &return_value_length
, &flags
, &rc
)))
2961 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2963 test_compare(MEMCACHED_NOTFOUND
, rc
);
2964 test_zero(return_value_length
);
2965 test_zero(return_key_length
);
2966 test_false(return_key
[0]);
2967 test_false(return_value
);
2969 for (std::vector
<char *>::iterator iter
= keys
.begin();
2976 memcached_free(memc_clone
);
2978 return TEST_SUCCESS
;
2982 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
2984 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2986 /* should work as of r580 */
2987 test_compare(TEST_SUCCESS
,
2988 _user_supplied_bug21(memc
, 10));
2990 /* should fail as of r580 */
2991 test_compare(TEST_SUCCESS
,
2992 _user_supplied_bug21(memc
, 1000));
2994 return TEST_SUCCESS
;
2997 static test_return_t
output_ketama_weighted_keys(memcached_st
*)
2999 memcached_st
*memc
= memcached_create(NULL
);
3003 test_compare(MEMCACHED_SUCCESS
,
3004 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
3006 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3007 test_compare(value
, uint64_t(1));
3009 test_compare(MEMCACHED_SUCCESS
,
3010 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3012 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3013 test_true(value
== MEMCACHED_HASH_MD5
);
3016 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3018 memcached_server_st
*server_pool
;
3019 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");
3020 memcached_server_push(memc
, server_pool
);
3022 // @todo this needs to be refactored to actually test something.
3025 if ((fp
= fopen("ketama_keys.txt", "w")))
3029 printf("cannot write to file ketama_keys.txt");
3030 return TEST_FAILURE
;
3033 for (int x
= 0; x
< 10000; x
++)
3036 snprintf(key
, sizeof(key
), "%d", x
);
3038 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3039 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3040 in_port_t port
= memc
->hosts
[server_idx
].port
;
3041 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3042 memcached_server_instance_st instance
=
3043 memcached_server_instance_by_position(memc
, host_index
);
3047 memcached_server_list_free(server_pool
);
3048 memcached_free(memc
);
3050 return TEST_SUCCESS
;
3054 static test_return_t
result_static(memcached_st
*memc
)
3056 memcached_result_st result
;
3057 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3058 test_false(result
.options
.is_allocated
);
3059 test_true(memcached_is_initialized(&result
));
3060 test_true(result_ptr
);
3061 test_true(result_ptr
== &result
);
3063 memcached_result_free(&result
);
3065 test_false(result
.options
.is_allocated
);
3066 test_false(memcached_is_initialized(&result
));
3068 return TEST_SUCCESS
;
3071 static test_return_t
result_alloc(memcached_st
*memc
)
3073 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3074 test_true(result_ptr
);
3075 test_true(result_ptr
->options
.is_allocated
);
3076 test_true(memcached_is_initialized(result_ptr
));
3077 memcached_result_free(result_ptr
);
3079 return TEST_SUCCESS
;
3082 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3085 pairs_free(global_pairs
);
3087 return TEST_SUCCESS
;
3090 static test_return_t
generate_pairs(memcached_st
*)
3092 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3093 global_count
= GLOBAL_COUNT
;
3095 for (size_t x
= 0; x
< global_count
; x
++)
3097 global_keys
[x
]= global_pairs
[x
].key
;
3098 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3101 return TEST_SUCCESS
;
3104 static test_return_t
generate_large_pairs(memcached_st
*)
3106 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3107 global_count
= GLOBAL2_COUNT
;
3109 for (size_t x
= 0; x
< global_count
; x
++)
3111 global_keys
[x
]= global_pairs
[x
].key
;
3112 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3115 return TEST_SUCCESS
;
3118 static test_return_t
generate_data(memcached_st
*memc
)
3120 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3122 test_compare_warn_hint(global_count
, check_execute
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3124 return TEST_SUCCESS
;
3127 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3129 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3131 test_compare(check_execute
, global_count
);
3133 // @todo hosts used size stats
3134 memcached_return_t rc
;
3135 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3138 for (uint32_t host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3140 /* This test was changes so that "make test" would work properlly */
3143 memcached_server_instance_st instance
=
3144 memcached_server_instance_by_position(memc
, host_index
);
3146 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3148 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3151 memcached_stat_free(NULL
, stat_p
);
3153 return TEST_SUCCESS
;
3155 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3157 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3158 generate_data(memc
);
3160 return TEST_SUCCESS
;
3163 static test_return_t
get_read_count(memcached_st
*memc
)
3165 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3166 test_true(memc_clone
);
3168 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3172 size_t return_value_length
;
3176 for (size_t x
= count
= 0; x
< global_count
; x
++)
3178 memcached_return_t rc
;
3179 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3180 &return_value_length
, &flags
, &rc
);
3181 if (rc
== MEMCACHED_SUCCESS
)
3192 memcached_free(memc_clone
);
3194 return TEST_SUCCESS
;
3197 static test_return_t
get_read(memcached_st
*memc
)
3199 size_t keys_returned
= 0;
3200 for (size_t x
= 0; x
< global_count
; x
++)
3202 size_t return_value_length
;
3204 memcached_return_t rc
;
3205 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3206 &return_value_length
, &flags
, &rc
);
3208 test_true(return_value);
3209 test_compare(MEMCACHED_SUCCESS, rc);
3211 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3217 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3219 return TEST_SUCCESS
;
3222 static test_return_t
mget_read(memcached_st
*memc
)
3225 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3227 test_compare(MEMCACHED_SUCCESS
,
3228 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3230 // Go fetch the keys and test to see if all of them were returned
3232 unsigned int keys_returned
;
3233 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
));
3234 test_true(keys_returned
> 0);
3235 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3238 return TEST_SUCCESS
;
3241 static test_return_t
mget_read_result(memcached_st
*memc
)
3244 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3246 test_compare(MEMCACHED_SUCCESS
,
3247 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3249 /* Turn this into a help function */
3251 memcached_result_st results_obj
;
3252 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3255 memcached_return_t rc
;
3256 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3258 if (rc
== MEMCACHED_IN_PROGRESS
)
3264 test_compare(MEMCACHED_SUCCESS
, rc
);
3266 test_compare(MEMCACHED_END
, rc
);
3268 memcached_result_free(&results_obj
);
3271 return TEST_SUCCESS
;
3274 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3277 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3279 test_compare(MEMCACHED_SUCCESS
,
3280 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3282 memcached_result_st
*results
= NULL
;
3283 memcached_return_t rc
;
3284 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3287 test_compare(MEMCACHED_SUCCESS
, rc
);
3289 test_compare(MEMCACHED_END
, rc
);
3291 memcached_result_free(results
);
3294 return TEST_SUCCESS
;
3297 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3300 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3302 test_compare(MEMCACHED_SUCCESS
,
3303 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3305 // We will scan for just one key
3307 memcached_result_st results_obj
;
3308 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3310 memcached_return_t rc
;
3311 results
= memcached_fetch_result(memc
, results
, &rc
);
3313 test_compare(MEMCACHED_SUCCESS
, rc
);
3315 memcached_result_free(&results_obj
);
3318 // We already have a read happening, lets start up another one.
3319 test_compare(MEMCACHED_SUCCESS
,
3320 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3322 memcached_result_st results_obj
;
3323 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3325 test_false(memcached_is_allocated(results
));
3327 memcached_return_t rc
;
3328 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3331 test_compare(MEMCACHED_SUCCESS
, rc
);
3333 test_compare(MEMCACHED_END
, rc
);
3335 memcached_result_free(&results_obj
);
3338 return TEST_SUCCESS
;
3341 static test_return_t
mget_read_function(memcached_st
*memc
)
3343 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3345 test_compare(MEMCACHED_SUCCESS
,
3346 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3348 memcached_execute_fn callbacks
[]= { &callback_counter
};
3350 test_compare(MEMCACHED_SUCCESS
,
3351 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3353 return TEST_SUCCESS
;
3356 static test_return_t
delete_generate(memcached_st
*memc
)
3359 for (size_t x
= 0; x
< global_count
; x
++)
3361 if (memcached_success(memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0)))
3366 test_compare_warn_hint(global_count
, total
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3368 return TEST_SUCCESS
;
3371 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3373 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3376 for (size_t x
= 0; x
< global_count
; x
++)
3378 if (memcached_success(memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0)))
3383 test_compare_warn_hint(global_count
, total
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3385 return TEST_SUCCESS
;
3388 static test_return_t
add_host_test1(memcached_st
*memc
)
3390 memcached_return_t rc
;
3391 char servername
[]= "0.example.com";
3393 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3395 test_compare(1U, memcached_server_list_count(servers
));
3397 for (uint32_t x
= 2; x
< 20; x
++)
3399 char buffer
[SMALL_STRING_LEN
];
3401 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3402 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3404 test_compare(MEMCACHED_SUCCESS
, rc
);
3405 test_compare(x
, memcached_server_list_count(servers
));
3408 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3409 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3411 memcached_server_list_free(servers
);
3413 return TEST_SUCCESS
;
3416 static test_return_t
pre_nonblock(memcached_st
*memc
)
3418 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3420 return TEST_SUCCESS
;
3423 static test_return_t
pre_cork(memcached_st
*memc
)
3426 return TEST_SKIPPED
;
3429 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3430 return TEST_SUCCESS
;
3432 return TEST_SKIPPED
;
3435 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3438 return TEST_SKIPPED
;
3440 test_return_t test_rc
;
3441 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3444 return pre_nonblock(memc
);
3447 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3449 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3450 test_true(memc_clone
);
3452 // The memcached_version needs to be done on a clone, because the server
3453 // will not toggle protocol on an connection.
3454 memcached_version(memc_clone
);
3456 memcached_return_t rc
= MEMCACHED_FAILURE
;
3457 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3459 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3460 test_compare(MEMCACHED_SUCCESS
,
3461 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3462 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3466 memcached_free(memc_clone
);
3467 return TEST_SKIPPED
;
3470 memcached_free(memc_clone
);
3472 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3475 static test_return_t
pre_murmur(memcached_st
*memc
)
3477 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3478 return TEST_SUCCESS
;
3481 static test_return_t
pre_jenkins(memcached_st
*memc
)
3483 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3485 return TEST_SKIPPED
;
3489 static test_return_t
pre_md5(memcached_st
*memc
)
3491 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3493 return TEST_SUCCESS
;
3496 static test_return_t
pre_crc(memcached_st
*memc
)
3498 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3500 return TEST_SUCCESS
;
3503 static test_return_t
pre_hsieh(memcached_st
*memc
)
3505 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
));
3506 return TEST_SUCCESS
;
3509 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3511 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3513 return TEST_SUCCESS
;
3516 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3518 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
));
3520 return TEST_SUCCESS
;
3523 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3525 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3527 return TEST_SUCCESS
;
3530 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3532 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3534 return TEST_SUCCESS
;
3537 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3539 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3540 test_compare(MEMCACHED_SUCCESS
, rc
);
3542 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3543 test_compare(value
, uint64_t(1));
3545 return TEST_SUCCESS
;
3548 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3550 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3551 test_compare(MEMCACHED_SUCCESS
, rc
);
3553 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3554 test_compare(value
, uint64_t(1));
3556 test_compare(MEMCACHED_SUCCESS
,
3557 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3559 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3560 test_compare(MEMCACHED_HASH_MD5
, memcached_hash_t(value
));
3562 return TEST_SUCCESS
;
3565 static test_return_t
pre_replication(memcached_st
*memc
)
3567 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3570 * Make sure that we store the item on all servers
3571 * (master + replicas == number of servers)
3573 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3574 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3576 return TEST_SUCCESS
;
3580 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3582 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3584 return pre_nonblock(memc
);
3588 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3592 #ifdef HARD_MALLOC_TESTS
3593 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3601 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3605 #ifdef HARD_MALLOC_TESTS
3606 void *ret
= malloc(size
+ 8);
3609 ret
= (void*)((caddr_t
)ret
+ 8);
3612 void *ret
= malloc(size
);
3617 memset(ret
, 0xff, size
);
3624 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3626 #ifdef HARD_MALLOC_TESTS
3627 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3628 void *nmem
= realloc(real_ptr
, size
+ 8);
3633 ret
= (void*)((caddr_t
)nmem
+ 8);
3639 return realloc(mem
, size
);
3644 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3646 #ifdef HARD_MALLOC_TESTS
3647 void *mem
= my_malloc(ptr
, nelem
* size
);
3650 memset(mem
, 0, nelem
* size
);
3656 return calloc(nelem
, size
);
3660 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3662 memcached_return_t rc
;
3663 const char *key
= "mine";
3666 /* Make sure be default none exists */
3667 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3669 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3671 /* Test a clean set */
3672 test_compare(MEMCACHED_SUCCESS
,
3673 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3675 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3677 test_memcmp(value
, key
, 4);
3678 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3680 /* Test that we can turn it off */
3681 test_compare(MEMCACHED_SUCCESS
,
3682 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3684 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3686 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3688 /* Now setup for main test */
3689 test_compare(MEMCACHED_SUCCESS
,
3690 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3692 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3694 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3695 test_memcmp(value
, key
, 4);
3697 /* Set to Zero, and then Set to something too large */
3700 memset(long_key
, 0, 255);
3702 test_compare(MEMCACHED_SUCCESS
,
3703 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3705 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3707 test_compare(MEMCACHED_SUCCESS
, rc
);
3709 /* Test a long key for failure */
3710 /* TODO, extend test to determine based on setting, what result should be */
3711 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3712 test_compare(MEMCACHED_SUCCESS
,
3713 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3715 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3716 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3717 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3718 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3720 /* Test for a bad prefix, but with a short key */
3721 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3722 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3724 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3725 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3728 return TEST_SUCCESS
;
3731 static test_return_t
set_namespace(memcached_st
*memc
)
3733 memcached_return_t rc
;
3734 const char *key
= "mine";
3737 // Make sure we default to a null namespace
3738 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3740 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3742 /* Test a clean set */
3743 test_compare(MEMCACHED_SUCCESS
,
3744 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3746 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3748 test_memcmp(value
, key
, 4);
3749 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3751 return TEST_SUCCESS
;
3754 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3756 test_return_if(pre_binary(memc
));
3757 test_return_if(set_namespace(memc
));
3759 return TEST_SUCCESS
;
3762 #ifdef MEMCACHED_ENABLE_DEPRECATED
3763 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3765 void *test_ptr
= NULL
;
3768 memcached_malloc_fn malloc_cb
=
3769 (memcached_malloc_fn
)my_malloc
;
3770 cb_ptr
= *(void **)&malloc_cb
;
3771 memcached_return_t rc
;
3773 test_compare(MEMCACHED_SUCCESS
,
3774 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3775 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3776 test_compare(MEMCACHED_SUCCESS
, rc
);
3777 test_true(test_ptr
== cb_ptr
);
3781 memcached_realloc_fn realloc_cb
=
3782 (memcached_realloc_fn
)my_realloc
;
3783 cb_ptr
= *(void **)&realloc_cb
;
3784 memcached_return_t rc
;
3786 test_compare(MEMCACHED_SUCCESS
,
3787 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3788 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3789 test_compare(MEMCACHED_SUCCESS
, rc
);
3790 test_true(test_ptr
== cb_ptr
);
3794 memcached_free_fn free_cb
=
3795 (memcached_free_fn
)my_free
;
3796 cb_ptr
= *(void **)&free_cb
;
3797 memcached_return_t rc
;
3799 test_compare(MEMCACHED_SUCCESS
,
3800 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3801 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3802 test_compare(MEMCACHED_SUCCESS
, rc
);
3803 test_true(test_ptr
== cb_ptr
);
3806 return TEST_SUCCESS
;
3811 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3813 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3814 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3815 my_realloc
, my_calloc
, NULL
));
3817 test_compare(MEMCACHED_SUCCESS
,
3818 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3819 my_realloc
, my_calloc
, NULL
));
3821 memcached_malloc_fn mem_malloc
;
3822 memcached_free_fn mem_free
;
3823 memcached_realloc_fn mem_realloc
;
3824 memcached_calloc_fn mem_calloc
;
3825 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3826 &mem_realloc
, &mem_calloc
);
3828 test_true(mem_malloc
== my_malloc
);
3829 test_true(mem_realloc
== my_realloc
);
3830 test_true(mem_calloc
== my_calloc
);
3831 test_true(mem_free
== my_free
);
3833 return TEST_SUCCESS
;
3836 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3839 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3840 memcached_hash_t hash
;
3841 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3842 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3845 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3846 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3848 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3850 if (hash
!= MEMCACHED_HASH_CRC
)
3851 return TEST_SKIPPED
;
3853 return TEST_SUCCESS
;
3856 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3859 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3860 memcached_hash_t hash
;
3861 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3862 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3867 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3868 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3870 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3872 if (hash
!= MEMCACHED_HASH_HSIEH
)
3873 return TEST_SKIPPED
;
3876 return TEST_SUCCESS
;
3879 static test_return_t
enable_cas(memcached_st
*memc
)
3881 unsigned int set
= 1;
3883 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3885 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3887 return TEST_SUCCESS
;
3890 return TEST_SKIPPED
;
3893 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3895 memcached_version(memc
);
3897 memcached_server_instance_st instance
=
3898 memcached_server_instance_by_position(memc
, 0);
3900 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3901 or instance
->minor_version
> 2)
3903 return TEST_SUCCESS
;
3906 return TEST_SKIPPED
;
3909 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3913 memcached_servers_reset(memc
);
3914 const char *socket_file
= default_socket();
3916 test_skip(0, stat(socket_file
, &buf
));
3918 test_compare(MEMCACHED_SUCCESS
,
3919 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
3921 return TEST_SUCCESS
;
3924 static test_return_t
pre_nodelay(memcached_st
*memc
)
3926 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3927 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3929 return TEST_SUCCESS
;
3932 static test_return_t
pre_settimer(memcached_st
*memc
)
3934 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3935 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3937 return TEST_SUCCESS
;
3940 static test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3942 const uint64_t timeout
= 100; // Not using, just checking that it sets
3944 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3946 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3948 return TEST_SUCCESS
;
3951 static test_return_t
noreply_test(memcached_st
*memc
)
3953 test_compare(MEMCACHED_SUCCESS
,
3954 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3955 test_compare(MEMCACHED_SUCCESS
,
3956 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3957 test_compare(MEMCACHED_SUCCESS
,
3958 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3959 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3960 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3961 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3963 memcached_return_t ret
;
3964 for (int count
= 0; count
< 5; ++count
)
3966 for (size_t x
= 0; x
< 100; ++x
)
3968 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3969 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3970 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3972 size_t len
= (size_t)check_length
;
3977 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3980 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3983 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3986 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3989 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3995 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, ret
));
3999 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4000 ** API and is _ONLY_ done this way to verify that the library works the
4001 ** way it is supposed to do!!!!
4004 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4006 memcached_server_instance_st instance
=
4007 memcached_server_instance_by_position(memc
, x
);
4008 no_msg
+=(int)(instance
->cursor_active
);
4011 test_true(no_msg
== 0);
4012 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4015 ** Now validate that all items was set properly!
4017 for (size_t x
= 0; x
< 100; ++x
)
4021 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4023 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4025 size_t len
= (size_t)check_length
;
4028 char* value
=memcached_get(memc
, key
, strlen(key
),
4029 &length
, &flags
, &ret
);
4030 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
4033 case 0: /* FALLTHROUGH */
4034 case 1: /* FALLTHROUGH */
4036 test_true(strncmp(value
, key
, len
) == 0);
4037 test_true(len
== length
);
4040 test_true(length
== len
* 2);
4043 test_true(length
== len
* 3);
4053 /* Try setting an illegal cas value (should not return an error to
4054 * the caller (because we don't expect a return message from the server)
4056 const char* keys
[]= {"0"};
4057 size_t lengths
[]= {1};
4060 memcached_result_st results_obj
;
4061 memcached_result_st
*results
;
4062 test_compare(MEMCACHED_SUCCESS
,
4063 memcached_mget(memc
, keys
, lengths
, 1));
4065 results
= memcached_result_create(memc
, &results_obj
);
4067 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4069 test_compare(MEMCACHED_SUCCESS
, ret
);
4070 uint64_t cas
= memcached_result_cas(results
);
4071 memcached_result_free(&results_obj
);
4073 test_compare(MEMCACHED_SUCCESS
,
4074 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4077 * The item will have a new cas value, so try to set it again with the old
4078 * value. This should fail!
4080 test_compare(MEMCACHED_SUCCESS
,
4081 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4082 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4083 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4084 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4087 return TEST_SUCCESS
;
4090 static test_return_t
analyzer_test(memcached_st
*memc
)
4092 memcached_return_t rc
;
4093 memcached_analysis_st
*report
;
4095 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4096 test_compare(MEMCACHED_SUCCESS
, rc
);
4097 test_true(memc_stat
);
4099 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4100 test_compare(MEMCACHED_SUCCESS
, rc
);
4104 memcached_stat_free(NULL
, memc_stat
);
4106 return TEST_SUCCESS
;
4109 /* Count the objects */
4111 static test_return_t
dump_test(memcached_st
*memc
)
4113 /* No support for Binary protocol yet */
4114 test_skip(false, memc
->flags
.binary_protocol
);
4116 test_compare(TEST_SUCCESS
, set_test3(memc
));
4118 // confirm_key_count() call dump
4119 size_t counter
= confirm_key_count(memc
);
4121 /* We may have more then 32 if our previous flush has not completed */
4122 test_true(counter
>= 32);
4124 return TEST_SUCCESS
;
4127 static test_return_t
util_version_test(memcached_st
*memc
)
4129 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
4130 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
4132 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4134 // We expect failure
4137 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4138 fprintf(stderr
, "\nDumping Server Information\n\n");
4139 memcached_server_fn callbacks
[1];
4141 callbacks
[0]= dump_server_information
;
4142 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4143 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4145 test_true(if_successful
== false);
4147 memcached_server_instance_st instance
=
4148 memcached_server_instance_by_position(memc
, 0);
4150 memcached_version(memc
);
4152 // We only use one binary when we test, so this should be just fine.
4153 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4154 test_true(if_successful
== true);
4156 if (instance
->micro_version
> 0)
4158 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4160 else if (instance
->minor_version
> 0)
4162 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4164 else if (instance
->major_version
> 0)
4166 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4169 test_true(if_successful
== true);
4171 if (instance
->micro_version
> 0)
4173 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4175 else if (instance
->minor_version
> 0)
4177 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4179 else if (instance
->major_version
> 0)
4181 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4184 test_true(if_successful
== false);
4186 return TEST_SUCCESS
;
4189 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4191 memcached_return_t rc
;
4192 memcached_server_instance_st instance
=
4193 memcached_server_instance_by_position(memc
, 0);
4195 // Test both the version that returns a code, and the one that does not.
4196 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4197 memcached_server_port(instance
) -1, NULL
) == -1);
4199 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4200 memcached_server_port(instance
) -1, &rc
) == -1);
4201 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4203 return TEST_SUCCESS
;
4207 static test_return_t
getpid_test(memcached_st
*memc
)
4209 memcached_return_t rc
;
4210 memcached_server_instance_st instance
=
4211 memcached_server_instance_by_position(memc
, 0);
4213 // Test both the version that returns a code, and the one that does not.
4214 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4215 memcached_server_port(instance
), NULL
) > -1);
4217 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4218 memcached_server_port(instance
), &rc
) > -1);
4219 test_compare(MEMCACHED_SUCCESS
, rc
);
4221 return TEST_SUCCESS
;
4224 static test_return_t
ping_test(memcached_st
*memc
)
4226 memcached_return_t rc
;
4227 memcached_server_instance_st instance
=
4228 memcached_server_instance_by_position(memc
, 0);
4230 // Test both the version that returns a code, and the one that does not.
4231 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4232 memcached_server_port(instance
), NULL
));
4234 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4235 memcached_server_port(instance
), &rc
));
4237 test_compare(MEMCACHED_SUCCESS
, rc
);
4239 return TEST_SUCCESS
;
4244 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4248 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4249 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4250 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4251 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4252 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4253 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4254 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4255 #ifdef HAVE_HSIEH_HASH
4256 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4258 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4259 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4260 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4262 return TEST_SUCCESS
;
4266 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4268 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4270 test_compare(MEMCACHED_SUCCESS
,
4271 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4272 (uint64_t)MEMCACHED_HASH_HSIEH
));
4274 return TEST_SUCCESS
;
4277 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4279 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4281 test_compare(MEMCACHED_SUCCESS
,
4282 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
4284 return TEST_SUCCESS
;
4287 static test_return_t
one_at_a_time_run (memcached_st
*)
4292 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4294 test_compare(one_at_a_time_values
[x
],
4295 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
4298 return TEST_SUCCESS
;
4301 static test_return_t
md5_run (memcached_st
*)
4306 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4308 test_compare(md5_values
[x
],
4309 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
4312 return TEST_SUCCESS
;
4315 static test_return_t
crc_run (memcached_st
*)
4320 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4322 test_compare(crc_values
[x
],
4323 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
4326 return TEST_SUCCESS
;
4329 static test_return_t
fnv1_64_run (memcached_st
*)
4331 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
4336 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4338 test_compare(fnv1_64_values
[x
],
4339 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
4342 return TEST_SUCCESS
;
4345 static test_return_t
fnv1a_64_run (memcached_st
*)
4347 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
4352 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4354 test_compare(fnv1a_64_values
[x
],
4355 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
4358 return TEST_SUCCESS
;
4361 static test_return_t
fnv1_32_run (memcached_st
*)
4366 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4368 test_compare(fnv1_32_values
[x
],
4369 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
4372 return TEST_SUCCESS
;
4375 static test_return_t
fnv1a_32_run (memcached_st
*)
4380 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4382 test_compare(fnv1a_32_values
[x
],
4383 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
4386 return TEST_SUCCESS
;
4389 static test_return_t
hsieh_run (memcached_st
*)
4391 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4396 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4398 test_compare(hsieh_values
[x
],
4399 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
4402 return TEST_SUCCESS
;
4405 static test_return_t
murmur_run (memcached_st
*)
4407 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4409 #ifdef WORDS_BIGENDIAN
4410 (void)murmur_values
;
4411 return TEST_SKIPPED
;
4416 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4418 test_compare(murmur_values
[x
],
4419 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
4422 return TEST_SUCCESS
;
4426 static test_return_t
jenkins_run (memcached_st
*)
4431 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4433 test_compare(jenkins_values
[x
],
4434 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
4437 return TEST_SUCCESS
;
4440 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
4442 return libhashkit_md5(string
, string_length
);
4445 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
4447 return libhashkit_crc32(string
, string_length
);
4450 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4456 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
4458 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};
4459 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};
4461 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4463 hashkit_clone(&new_kit
, kit
);
4464 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4466 memcached_set_hashkit(memc
, &new_kit
);
4469 Verify Setting the hash.
4471 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4475 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4476 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4481 Now check memcached_st.
4483 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4487 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4488 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4491 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4493 memcached_set_hashkit(memc
, &new_kit
);
4496 Verify Setting the hash.
4498 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4502 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4503 test_true(crc_values
[x
] == hash_val
);
4506 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4510 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4511 test_compare(crc_hosts
[x
], hash_val
);
4514 memcached_free(memc
);
4516 return TEST_SUCCESS
;
4520 Test case adapted from John Gorman <johngorman2@gmail.com>
4522 We are testing the error condition when we connect to a server via memcached_get()
4523 but find that the server is not available.
4525 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4527 const char *key
= "MemcachedLives";
4530 memcached_return rc
;
4533 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4535 // See if memcached is reachable.
4536 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4540 test_true(memcached_failed(rc
));
4542 memcached_free(tl_memc_h
);
4544 return TEST_SUCCESS
;
4548 We connect to a server which exists, but search for a key that does not exist.
4550 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4552 const char *key
= "MemcachedKeyNotEXIST";
4555 memcached_return rc
;
4557 // See if memcached is reachable.
4558 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4562 test_compare(MEMCACHED_NOTFOUND
, rc
);
4564 return TEST_SUCCESS
;
4568 Test case adapted from John Gorman <johngorman2@gmail.com>
4570 We are testing the error condition when we connect to a server via memcached_get_by_key()
4571 but find that the server is not available.
4573 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4576 memcached_st
*tl_memc_h
;
4577 memcached_server_st
*servers
;
4579 const char *key
= "MemcachedLives";
4582 memcached_return rc
;
4586 tl_memc_h
= memcached_create(NULL
);
4587 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4588 memcached_server_push(tl_memc_h
, servers
);
4589 memcached_server_list_free(servers
);
4591 // See if memcached is reachable.
4592 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4596 test_true(memcached_failed(rc
));
4598 memcached_free(tl_memc_h
);
4600 return TEST_SUCCESS
;
4604 We connect to a server which exists, but search for a key that does not exist.
4606 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4608 const char *key
= "MemcachedKeyNotEXIST";
4611 memcached_return rc
;
4614 // See if memcached is reachable.
4615 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4619 test_compare(MEMCACHED_NOTFOUND
, rc
);
4621 return TEST_SUCCESS
;
4624 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4626 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4628 const char *key
= "regression_bug_434484";
4629 size_t keylen
= strlen(key
);
4631 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4632 test_compare(MEMCACHED_NOTSTORED
, ret
);
4634 size_t size
= 2048 * 1024;
4635 char *data
= (char*)calloc(1, size
);
4637 test_compare(MEMCACHED_E2BIG
,
4638 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4641 return TEST_SUCCESS
;
4644 static test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4646 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4648 memcached_return_t rc
;
4650 memcached_execute_fn callbacks
[]= { &callback_counter
};
4653 * I only want to hit only _one_ server so I know the number of requests I'm
4654 * sending in the pipleine to the server. Let's try to do a multiget of
4655 * 1024 (that should satisfy most users don't you think?). Future versions
4656 * will include a mget_execute function call if you need a higher number.
4658 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4660 const size_t max_keys
= 1024;
4661 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4662 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4664 for (size_t x
= 0; x
< max_keys
; ++x
)
4668 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4674 * Run two times.. the first time we should have 100% cache miss,
4675 * and the second time we should have 100% cache hits
4677 for (size_t y
= 0; y
< 2; y
++)
4679 test_compare(MEMCACHED_SUCCESS
,
4680 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4682 // One the first run we should get a NOT_FOUND, but on the second some data
4683 // should be returned.
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
},
5667 {"memcached_dump()", 0, (test_callback_fn
*)memcached_dump_TEST
},
5671 test_st touch_tests
[] ={
5672 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5673 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5677 test_st behavior_tests
[] ={
5678 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5679 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5680 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5681 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5682 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5683 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5684 {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test
},
5685 {"MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY", false, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY
},
5689 test_st libmemcachedutil_tests
[] ={
5690 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5691 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5692 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5696 test_st basic_tests
[] ={
5697 {"init", true, (test_callback_fn
*)basic_init_test
},
5698 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5699 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5700 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5701 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5702 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5703 {"memcached_return_t", false, (test_callback_fn
*)memcached_return_t_TEST
},
5707 test_st regression_binary_vs_block
[] ={
5708 {"block add", true, (test_callback_fn
*)block_add_regression
},
5709 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
5713 test_st async_tests
[] ={
5714 {"add", true, (test_callback_fn
*)add_wrapper
},
5718 test_st memcached_server_get_last_disconnect_tests
[] ={
5719 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
5720 {0, 0, (test_callback_fn
*)0}
5724 test_st result_tests
[] ={
5725 {"result static", false, (test_callback_fn
*)result_static
},
5726 {"result alloc", false, (test_callback_fn
*)result_alloc
},
5727 {0, 0, (test_callback_fn
*)0}
5730 test_st version_1_2_3
[] ={
5731 {"append", false, (test_callback_fn
*)append_test
},
5732 {"prepend", false, (test_callback_fn
*)prepend_test
},
5733 {"cas", false, (test_callback_fn
*)cas_test
},
5734 {"cas2", false, (test_callback_fn
*)cas2_test
},
5735 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
5736 {0, 0, (test_callback_fn
*)0}
5739 test_st haldenbrand_tests
[] ={
5740 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
5741 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
5742 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
5743 {0, 0, (test_callback_fn
*)0}
5746 test_st user_tests
[] ={
5747 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
5748 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
5749 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
5750 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
5751 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
5752 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
5753 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
5754 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
5755 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
5756 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
5757 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
5758 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
5759 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
5760 #if !defined(__sun) && !defined(__OpenBSD__)
5762 ** It seems to be something weird with the character sets..
5763 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5764 ** guess I need to find out how this is supposed to work.. Perhaps I need
5765 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5766 ** so just disable the code for now...).
5768 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
5770 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
5771 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
5772 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
5773 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
5774 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
5775 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
5776 {0, 0, (test_callback_fn
*)0}
5779 test_st replication_tests
[]= {
5780 {"set", true, (test_callback_fn
*)replication_set_test
},
5781 {"get", false, (test_callback_fn
*)replication_get_test
},
5782 {"mget", false, (test_callback_fn
*)replication_mget_test
},
5783 {"delete", true, (test_callback_fn
*)replication_delete_test
},
5784 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
5785 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
5786 {0, 0, (test_callback_fn
*)0}
5790 * The following test suite is used to verify that we don't introduce
5791 * regression bugs. If you want more information about the bug / test,
5792 * you should look in the bug report at
5793 * http://bugs.launchpad.net/libmemcached
5795 test_st regression_tests
[]= {
5796 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
5797 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
5798 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
5799 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
5800 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
5801 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
5802 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
5803 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
5804 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
5805 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
5806 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
5807 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
5808 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
5809 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
5810 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
5811 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
5812 {"lp:854604", true, (test_callback_fn
*)regression_bug_854604
},
5813 {0, false, (test_callback_fn
*)0}
5816 test_st ketama_compatibility
[]= {
5817 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
5818 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
5819 {0, 0, (test_callback_fn
*)0}
5822 test_st generate_tests
[] ={
5823 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5824 {"generate_data", true, (test_callback_fn
*)generate_data
},
5825 {"get_read", false, (test_callback_fn
*)get_read
},
5826 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
5827 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5828 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
5829 {"generate_data", true, (test_callback_fn
*)generate_data
},
5830 {"mget_read", false, (test_callback_fn
*)mget_read
},
5831 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
5832 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
5833 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
5834 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
5835 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5836 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
5837 {"generate_data", true, (test_callback_fn
*)generate_data
},
5838 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5839 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5840 {0, 0, (test_callback_fn
*)0}
5843 test_st consistent_tests
[] ={
5844 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5845 {"generate_data", true, (test_callback_fn
*)generate_data
},
5846 {"get_read", 0, (test_callback_fn
*)get_read_count
},
5847 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5848 {0, 0, (test_callback_fn
*)0}
5851 test_st consistent_weighted_tests
[] ={
5852 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5853 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
5854 {"get_read", false, (test_callback_fn
*)get_read_count
},
5855 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5856 {0, 0, (test_callback_fn
*)0}
5859 test_st hsieh_availability
[] ={
5860 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
5861 {0, 0, (test_callback_fn
*)0}
5864 test_st murmur_availability
[] ={
5865 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
5866 {0, 0, (test_callback_fn
*)0}
5870 test_st hash_sanity
[] ={
5871 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
5872 {0, 0, (test_callback_fn
*)0}
5876 test_st ketama_auto_eject_hosts
[] ={
5877 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
5878 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
5879 {0, 0, (test_callback_fn
*)0}
5882 test_st hash_tests
[] ={
5883 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
5884 {"md5", false, (test_callback_fn
*)md5_run
},
5885 {"crc", false, (test_callback_fn
*)crc_run
},
5886 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
5887 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
5888 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
5889 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
5890 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
5891 {"murmur", false, (test_callback_fn
*)murmur_run
},
5892 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
5893 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
5894 {0, 0, (test_callback_fn
*)0}
5897 test_st error_conditions
[] ={
5898 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
5899 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
5900 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
5901 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5902 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5903 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
5904 {0, 0, (test_callback_fn
*)0}
5907 test_st parser_tests
[] ={
5908 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
5909 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
5910 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
5911 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
5912 {"hash", false, (test_callback_fn
*)parser_hash_test
},
5913 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
5914 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
5915 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
5916 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
5917 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
5918 {"server", false, (test_callback_fn
*)server_test
},
5919 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
5920 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
5921 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
5922 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
5923 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
5924 {0, 0, (test_callback_fn
*)0}
5927 test_st virtual_bucket_tests
[] ={
5928 {"basic", false, (test_callback_fn
*)virtual_back_map
},
5929 {0, 0, (test_callback_fn
*)0}
5932 test_st memcached_server_add_tests
[] ={
5933 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
5934 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
5935 {0, 0, (test_callback_fn
*)0}
5938 test_st namespace_tests
[] ={
5939 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
5940 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
5941 {0, 0, (test_callback_fn
*)0}
5944 collection_st collection
[] ={
5946 {"hash_sanity", 0, 0, hash_sanity
},
5948 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
5949 {"basic", 0, 0, basic_tests
},
5950 {"hsieh_availability", 0, 0, hsieh_availability
},
5951 {"murmur_availability", 0, 0, murmur_availability
},
5952 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
5953 {"block", 0, 0, tests
},
5954 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
5955 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
5956 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5957 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
5958 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
5959 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
5960 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
5961 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
5962 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
5963 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
5964 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
5965 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
5966 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
5967 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
5968 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
5969 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5970 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
5971 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
5972 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
5973 #ifdef MEMCACHED_ENABLE_DEPRECATED
5974 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
5976 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
5977 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
5978 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
5979 {"specific namespace", 0, 0, namespace_tests
},
5980 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
5981 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
5982 {"result", 0, 0, result_tests
},
5983 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
5984 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
5985 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
5986 {"user written tests", 0, 0, user_tests
},
5987 {"generate", 0, 0, generate_tests
},
5988 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
5989 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
5990 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
5991 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
5992 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
5993 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
5994 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
5996 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
5997 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
5998 {"consistent_not", 0, 0, consistent_tests
},
5999 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
6000 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6001 {"ketama_compat", 0, 0, ketama_compatibility
},
6002 {"test_hashes", 0, 0, hash_tests
},
6003 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6004 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6005 {"regression", 0, 0, regression_tests
},
6006 {"behaviors", 0, 0, behavior_tests
},
6007 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6008 {"error_conditions", 0, 0, error_conditions
},
6009 {"parser", 0, 0, parser_tests
},
6010 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6011 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6012 {"touch", 0, 0, touch_tests
},
6013 {"touch", (test_callback_fn
*)pre_binary
, 0, touch_tests
},
6017 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
6019 #include "tests/libmemcached_world.h"
6021 void get_world(Framework
*world
)
6023 world
->collections
= collection
;
6025 world
->_create
= (test_callback_create_fn
*)world_create
;
6026 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6028 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6029 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6030 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6031 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6032 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6034 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6035 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6037 world
->set_runner(&defualt_libmemcached_runner
);
6039 world
->set_socket();