1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 #include <libtest/test.hpp>
45 #include <libmemcached-1.0/memcached.h>
46 #include <libmemcached/is.h>
47 #include <libmemcached/server_instance.h>
49 #include <libhashkit-1.0/hashkit.h>
55 #include <semaphore.h>
59 #include <sys/types.h>
64 #include <libtest/server.h>
66 #include "clients/generator.h"
67 #include "clients/execute.h"
69 #define SMALL_STRING_LEN 1024
71 #include <libtest/test.hpp>
73 #include "tests/basic.h"
74 #include "tests/debug.h"
75 #include "tests/deprecated.h"
76 #include "tests/error_conditions.h"
77 #include "tests/exist.h"
78 #include "tests/ketama.h"
79 #include "tests/namespace.h"
80 #include "tests/parser.h"
81 #include "tests/touch.h"
82 #include "tests/callbacks.h"
83 #include "tests/pool.h"
84 #include "tests/print.h"
85 #include "tests/replication.h"
86 #include "tests/server_add.h"
87 #include "tests/virtual_buckets.h"
89 using namespace libtest
;
91 #include <libmemcached/util.h>
93 #include "tests/hash_results.h"
95 #define GLOBAL_COUNT 10000
96 #define GLOBAL2_COUNT 100
97 #define SERVERS_TO_CREATE 5
98 static uint32_t global_count
= GLOBAL2_COUNT
;
100 static pairs_st
*global_pairs
;
101 static const char *global_keys
[GLOBAL_COUNT
];
102 static size_t global_keys_length
[GLOBAL_COUNT
];
105 @note This should be testing to see if the server really supports the binary protocol.
107 static test_return_t
pre_binary(memcached_st
*memc
)
109 test_skip(true, libmemcached_util_version_check(memc
, 1, 4, 4));
110 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
115 static memcached_return_t
return_value_based_on_buffering(memcached_st
*memc
)
117 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
))
119 return MEMCACHED_BUFFERED
;
122 return MEMCACHED_SUCCESS
;
125 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
128 * I only want to hit _one_ server so I know the number of requests I'm
129 * sending in the pipeline.
131 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
133 char server_string
[1024];
134 int server_string_length
;
137 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
138 memcached_server_name(instance
), int(memcached_server_port(instance
)),
143 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
144 memcached_server_name(instance
), int(memcached_server_port(instance
)));
147 if (server_string_length
<= 0)
153 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, buffer
, sizeof(buffer
))))
155 Error
<< "Failed to parse " << server_string_length
;
159 return memcached(server_string
, server_string_length
);
163 static test_return_t
init_test(memcached_st
*not_used
)
168 (void)memcached_create(&memc
);
169 memcached_free(&memc
);
174 #define TEST_PORT_COUNT 7
175 in_port_t test_ports
[TEST_PORT_COUNT
];
177 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
178 const memcached_server_st
*server
,
182 size_t bigger
= *((size_t *)(context
));
184 assert(bigger
<= memcached_server_port(server
));
185 *((size_t *)(context
))= memcached_server_port(server
);
187 return MEMCACHED_SUCCESS
;
190 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
191 const memcached_server_st
*instance
,
195 FILE *stream
= (FILE *)context
;
198 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
199 memcached_server_name(instance
),
200 memcached_server_port(instance
),
201 instance
->major_version
,
202 instance
->minor_version
,
203 instance
->micro_version
);
205 return MEMCACHED_SUCCESS
;
208 static test_return_t
server_sort_test(memcached_st
*ptr
)
210 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
212 memcached_return_t rc
;
213 memcached_server_fn callbacks
[1];
214 memcached_st
*local_memc
;
217 local_memc
= memcached_create(NULL
);
218 test_true(local_memc
);
219 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
221 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
223 test_ports
[x
]= (in_port_t
)random() % 64000;
224 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
225 test_compare(memcached_server_count(local_memc
), x
+1);
227 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
229 test_compare(MEMCACHED_SUCCESS
, rc
);
232 callbacks
[0]= server_display_function
;
233 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
236 memcached_free(local_memc
);
241 static test_return_t
server_sort2_test(memcached_st
*ptr
)
243 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
244 memcached_server_fn callbacks
[1];
245 memcached_st
*local_memc
;
246 memcached_server_instance_st instance
;
249 local_memc
= memcached_create(NULL
);
250 test_true(local_memc
);
251 test_compare(MEMCACHED_SUCCESS
,
252 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
254 test_compare(MEMCACHED_SUCCESS
,
255 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
256 instance
= memcached_server_instance_by_position(local_memc
, 0);
257 test_compare(in_port_t(43043), memcached_server_port(instance
));
259 test_compare(MEMCACHED_SUCCESS
,
260 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
262 instance
= memcached_server_instance_by_position(local_memc
, 0);
263 test_compare(in_port_t(43042), memcached_server_port(instance
));
265 instance
= memcached_server_instance_by_position(local_memc
, 1);
266 test_compare(in_port_t(43043), memcached_server_port(instance
));
268 callbacks
[0]= server_display_function
;
269 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
272 memcached_free(local_memc
);
277 static test_return_t
memcached_server_remove_test(memcached_st
*)
279 const char *server_string
= "--server=localhost:4444 --server=localhost:4445 --server=localhost:4446 --server=localhost:4447 --server=localhost --server=memcache1.memcache.bk.sapo.pt:11211 --server=memcache1.memcache.bk.sapo.pt:11212 --server=memcache1.memcache.bk.sapo.pt:11213 --server=memcache1.memcache.bk.sapo.pt:11214 --server=memcache2.memcache.bk.sapo.pt:11211 --server=memcache2.memcache.bk.sapo.pt:11212 --server=memcache2.memcache.bk.sapo.pt:11213 --server=memcache2.memcache.bk.sapo.pt:11214";
282 test_compare(MEMCACHED_SUCCESS
,
283 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
284 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
287 memcached_server_fn callbacks
[1];
288 callbacks
[0]= server_print_callback
;
289 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
291 memcached_free(memc
);
296 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
297 const memcached_server_st
*server
,
301 uint32_t x
= *((uint32_t *)(context
));
303 if (! (test_ports
[x
] == server
->port
))
305 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
306 return MEMCACHED_FAILURE
;
309 *((uint32_t *)(context
))= ++x
;
311 return MEMCACHED_SUCCESS
;
314 static test_return_t
server_unsort_test(memcached_st
*ptr
)
316 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
317 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
318 memcached_server_fn callbacks
[1];
319 memcached_st
*local_memc
;
322 local_memc
= memcached_create(NULL
);
323 test_true(local_memc
);
325 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
327 test_ports
[x
]= (in_port_t
)(random() % 64000);
328 test_compare(MEMCACHED_SUCCESS
,
329 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
330 test_compare(memcached_server_count(local_memc
), x
+1);
332 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
336 callbacks
[0]= server_display_unsort_function
;
337 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
339 /* Now we sort old data! */
340 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
341 callbacks
[0]= server_display_function
;
342 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
345 memcached_free(local_memc
);
350 static test_return_t
allocation_test(memcached_st
*not_used
)
354 memc
= memcached_create(NULL
);
356 memcached_free(memc
);
361 static test_return_t
clone_test(memcached_st
*memc
)
365 memcached_st
*memc_clone
;
366 memc_clone
= memcached_clone(NULL
, NULL
);
367 test_true(memc_clone
);
368 memcached_free(memc_clone
);
371 /* Can we init from null? */
373 memcached_st
*memc_clone
;
374 memc_clone
= memcached_clone(NULL
, memc
);
375 test_true(memc_clone
);
378 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
379 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
380 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
381 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
384 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
385 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
386 test_true(memc_clone
->distribution
== memc
->distribution
);
387 { // Test all of the flags
388 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
389 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
390 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
391 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
392 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
393 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
394 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
395 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
396 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
397 test_true(memc_clone
->flags
.reply
== memc
->flags
.reply
);
398 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
399 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
400 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
402 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
403 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
404 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
405 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
406 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
407 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
408 test_true(memc_clone
->on_clone
== memc
->on_clone
);
409 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
410 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
411 test_true(memc_clone
->recv_size
== memc
->recv_size
);
412 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
413 test_true(memc_clone
->send_size
== memc
->send_size
);
414 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
415 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
416 test_true(memc_clone
->user_data
== memc
->user_data
);
418 memcached_free(memc_clone
);
421 /* Can we init from struct? */
423 memcached_st declared_clone
;
424 memcached_st
*memc_clone
;
425 memset(&declared_clone
, 0 , sizeof(memcached_st
));
426 memc_clone
= memcached_clone(&declared_clone
, NULL
);
427 test_true(memc_clone
);
428 memcached_free(memc_clone
);
431 /* Can we init from struct? */
433 memcached_st declared_clone
;
434 memcached_st
*memc_clone
;
435 memset(&declared_clone
, 0 , sizeof(memcached_st
));
436 memc_clone
= memcached_clone(&declared_clone
, memc
);
437 test_true(memc_clone
);
438 memcached_free(memc_clone
);
444 static test_return_t
userdata_test(memcached_st
*memc
)
447 test_false(memcached_set_user_data(memc
, foo
));
448 test_true(memcached_get_user_data(memc
) == foo
);
449 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
454 static test_return_t
connection_test(memcached_st
*memc
)
456 test_compare(MEMCACHED_SUCCESS
,
457 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
462 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
464 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
466 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
468 test_compare(36, int(MEMCACHED_BEHAVIOR_MAX
));
473 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
475 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
477 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
479 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
484 static test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
486 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
487 982370485U, 1263635348U, 4242906218U, 3829656100U,
488 1891735253U, 334139633U, 2257084983U, 3088286104U,
489 13199785U, 2542027183U, 1097051614U, 199566778U,
490 2748246961U, 2465192557U, 1664094137U, 2405439045U,
491 1842224848U, 692413798U, 3479807801U, 919913813U,
492 4269430871U, 610793021U, 527273862U, 1437122909U,
493 2300930706U, 2943759320U, 674306647U, 2400528935U,
494 54481931U, 4186304426U, 1741088401U, 2979625118U,
495 4159057246U, 3425930182U, 2593724503U, 1868899624U,
496 1769812374U, 2302537950U, 1110330676U, 3365377466U,
497 1336171666U, 3021258493U, 2334992265U, 3861994737U,
498 3582734124U, 3365377466U };
500 // You have updated the memcache_error messages but not updated docs/tests.
501 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
504 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
505 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
506 MEMCACHED_HASH_JENKINS
);
507 if (values
[rc
] != hash_val
)
509 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
510 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
512 test_compare(values
[rc
], hash_val
);
514 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
519 static test_return_t
set_test(memcached_st
*memc
)
521 memcached_return_t rc
= memcached_set(memc
,
522 test_literal_param("foo"),
523 test_literal_param("when we sanitize"),
524 time_t(0), (uint32_t)0);
525 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
530 static test_return_t
append_test(memcached_st
*memc
)
532 memcached_return_t rc
;
533 const char *in_value
= "we";
537 test_compare(MEMCACHED_SUCCESS
,
538 memcached_flush(memc
, 0));
540 test_compare(MEMCACHED_SUCCESS
,
542 test_literal_param(__func__
),
543 in_value
, strlen(in_value
),
544 time_t(0), uint32_t(0)));
546 test_compare(MEMCACHED_SUCCESS
,
547 memcached_append(memc
,
548 test_literal_param(__func__
),
549 " the", strlen(" the"),
550 time_t(0), uint32_t(0)));
552 test_compare(MEMCACHED_SUCCESS
,
553 memcached_append(memc
,
554 test_literal_param(__func__
),
555 " people", strlen(" people"),
556 time_t(0), uint32_t(0)));
558 char *out_value
= memcached_get(memc
,
559 test_literal_param(__func__
),
560 &value_length
, &flags
, &rc
);
561 test_memcmp(out_value
, "we the people", strlen("we the people"));
562 test_compare(strlen("we the people"), value_length
);
563 test_compare(MEMCACHED_SUCCESS
, rc
);
569 static test_return_t
append_binary_test(memcached_st
*memc
)
571 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
573 test_compare(MEMCACHED_SUCCESS
,
574 memcached_flush(memc
, 0));
576 test_compare(MEMCACHED_SUCCESS
,
578 test_literal_param(__func__
),
580 time_t(0), uint32_t(0)));
583 for (uint32_t x
= 0; store_list
[x
] ; x
++)
585 test_compare(MEMCACHED_SUCCESS
,
586 memcached_append(memc
,
587 test_literal_param(__func__
),
588 (char *)&store_list
[x
], sizeof(uint32_t),
589 time_t(0), uint32_t(0)));
595 memcached_return_t rc
;
596 uint32_t *value
= (uint32_t *)memcached_get(memc
,
597 test_literal_param(__func__
),
598 &value_length
, &flags
, &rc
);
599 test_compare(value_length
, sizeof(uint32_t) * count
);
600 test_compare(MEMCACHED_SUCCESS
, rc
);
602 for (uint32_t counter
= count
, *ptr
= value
; counter
; counter
--)
604 test_compare(*ptr
, store_list
[count
- counter
]);
612 static test_return_t
cas2_test(memcached_st
*memc
)
614 const char *keys
[]= {"fudge", "son", "food"};
615 size_t key_length
[]= {5, 3, 4};
616 const char *value
= "we the people";
617 size_t value_length
= strlen("we the people");
619 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
621 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
623 for (uint32_t x
= 0; x
< 3; x
++)
625 test_compare(MEMCACHED_SUCCESS
,
626 memcached_set(memc
, keys
[x
], key_length
[x
],
627 keys
[x
], key_length
[x
],
628 time_t(50), uint32_t(9)));
631 test_compare(MEMCACHED_SUCCESS
,
632 memcached_mget(memc
, keys
, key_length
, 3));
634 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
637 memcached_return_t rc
;
638 results
= memcached_fetch_result(memc
, results
, &rc
);
640 test_true(results
->item_cas
);
641 test_compare(MEMCACHED_SUCCESS
, rc
);
642 test_true(memcached_result_cas(results
));
644 test_memcmp(value
, "we the people", strlen("we the people"));
645 test_compare(strlen("we the people"), value_length
);
646 test_compare(MEMCACHED_SUCCESS
, rc
);
648 memcached_result_free(results
);
653 static test_return_t
cas_test(memcached_st
*memc
)
655 const char* keys
[2] = { __func__
, NULL
};
656 size_t keylengths
[2] = { strlen(__func__
), 0 };
658 memcached_result_st results_obj
;
660 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
662 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
664 test_compare(MEMCACHED_SUCCESS
,
666 test_literal_param(__func__
),
667 test_literal_param("we the people"),
668 (time_t)0, (uint32_t)0));
670 test_compare(MEMCACHED_SUCCESS
,
671 memcached_mget(memc
, keys
, keylengths
, 1));
673 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
676 memcached_return_t rc
;
677 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
679 test_compare(MEMCACHED_SUCCESS
, rc
);
680 test_true(memcached_result_cas(results
));
681 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
682 test_compare(test_literal_param_size("we the people"),
683 strlen(memcached_result_value(results
)));
685 uint64_t cas
= memcached_result_cas(results
);
688 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
689 test_true(rc
== MEMCACHED_END
);
690 test_true(results
== NULL
);
693 test_compare(MEMCACHED_SUCCESS
,
695 test_literal_param(__func__
),
696 test_literal_param("change the value"),
700 * The item will have a new cas value, so try to set it again with the old
701 * value. This should fail!
703 test_compare(MEMCACHED_DATA_EXISTS
,
705 test_literal_param(__func__
),
706 test_literal_param("change the value"),
709 memcached_result_free(&results_obj
);
714 static test_return_t
prepend_test(memcached_st
*memc
)
716 const char *key
= "fig";
717 const char *value
= "people";
719 test_compare(MEMCACHED_SUCCESS
,
720 memcached_flush(memc
, 0));
722 test_compare(MEMCACHED_SUCCESS
,
723 memcached_set(memc
, key
, strlen(key
),
724 value
, strlen(value
),
725 time_t(0), uint32_t(0)));
727 test_compare(MEMCACHED_SUCCESS
,
728 memcached_prepend(memc
, key
, strlen(key
),
729 "the ", strlen("the "),
730 time_t(0), uint32_t(0)));
732 test_compare(MEMCACHED_SUCCESS
,
733 memcached_prepend(memc
, key
, strlen(key
),
734 "we ", strlen("we "),
735 time_t(0), uint32_t(0)));
739 memcached_return_t rc
;
740 char *out_value
= memcached_get(memc
, key
, strlen(key
),
741 &value_length
, &flags
, &rc
);
742 test_memcmp(out_value
, "we the people", strlen("we the people"));
743 test_compare(strlen("we the people"), value_length
);
744 test_compare(MEMCACHED_SUCCESS
, rc
);
751 Set the value, then quit to make sure it is flushed.
752 Come back in and test that add fails.
754 static test_return_t
add_test(memcached_st
*memc
)
756 test_compare_hint(return_value_based_on_buffering(memc
),
758 test_literal_param(__func__
),
759 test_literal_param("when we sanitize"),
760 time_t(0), uint32_t(0)),
761 memcached_last_error_message(memc
));
763 memcached_quit(memc
);
765 test_compare_hint(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
767 test_literal_param(__func__
),
768 test_literal_param("try something else"),
769 time_t(0), uint32_t(0)),
770 memcached_last_error_message(memc
));
776 ** There was a problem of leaking filedescriptors in the initial release
777 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
778 ** systems it seems that the kernel is slow on reclaiming the resources
779 ** because the connects starts to time out (the test doesn't do much
780 ** anyway, so just loop 10 iterations)
782 static test_return_t
add_wrapper(memcached_st
*memc
)
784 unsigned int max
= 10000;
792 for (uint32_t x
= 0; x
< max
; x
++)
798 static test_return_t
replace_test(memcached_st
*memc
)
800 test_compare(return_value_based_on_buffering(memc
),
802 test_literal_param(__func__
),
803 test_literal_param("when we sanitize"),
804 time_t(0), uint32_t(0)));
806 test_compare(MEMCACHED_SUCCESS
,
807 memcached_replace(memc
,
808 test_literal_param(__func__
),
809 test_literal_param("first we insert some data"),
810 time_t(0), uint32_t(0)));
815 static test_return_t
delete_test(memcached_st
*memc
)
817 test_compare(return_value_based_on_buffering(memc
),
819 test_literal_param(__func__
),
820 test_literal_param("when we sanitize"),
821 time_t(0), uint32_t(0)));
823 test_compare_hint(return_value_based_on_buffering(memc
),
824 memcached_delete(memc
,
825 test_literal_param(__func__
),
827 memcached_last_error_message(memc
));
832 static test_return_t
flush_test(memcached_st
*memc
)
834 uint64_t query_id
= memcached_query_id(memc
);
835 test_compare(MEMCACHED_SUCCESS
,
836 memcached_flush(memc
, 0));
837 test_compare(query_id
+1, memcached_query_id(memc
));
842 static memcached_return_t
server_function(const memcached_st
*,
843 const memcached_server_st
*,
847 return MEMCACHED_SUCCESS
;
850 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
853 strncpy(context
, "foo bad", sizeof(context
));
854 memcached_server_fn callbacks
[1];
856 callbacks
[0]= server_function
;
857 memcached_server_cursor(memc
, callbacks
, context
, 1);
861 static test_return_t
bad_key_test(memcached_st
*memc
)
863 memcached_return_t rc
;
864 const char *key
= "foo bad";
867 uint64_t query_id
= memcached_query_id(memc
);
869 // Just skip if we are in binary mode.
870 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
872 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
874 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
875 test_true(memc_clone
);
877 query_id
= memcached_query_id(memc_clone
);
878 test_compare(MEMCACHED_SUCCESS
,
879 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
880 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
882 /* All keys are valid in the binary protocol (except for length) */
883 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
885 uint64_t before_query_id
= memcached_query_id(memc_clone
);
887 size_t string_length
;
888 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
889 &string_length
, &flags
, &rc
);
890 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
891 test_zero(string_length
);
894 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
896 query_id
= memcached_query_id(memc_clone
);
897 test_compare(MEMCACHED_SUCCESS
,
898 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
899 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
901 size_t string_length
;
902 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
903 &string_length
, &flags
, &rc
);
904 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
905 test_zero(string_length
);
909 /* Test multi key for bad keys */
910 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
911 size_t key_lengths
[] = { 7, 7, 7 };
912 query_id
= memcached_query_id(memc_clone
);
913 test_compare(MEMCACHED_SUCCESS
,
914 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
915 test_compare(query_id
, memcached_query_id(memc_clone
));
917 query_id
= memcached_query_id(memc_clone
);
918 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
919 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
920 test_compare(query_id
+1, memcached_query_id(memc_clone
));
922 query_id
= memcached_query_id(memc_clone
);
923 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
924 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
925 test_compare(query_id
+1, memcached_query_id(memc_clone
));
927 /* The following test should be moved to the end of this function when the
928 memcached server is updated to allow max size length of the keys in the
931 test_compare(MEMCACHED_SUCCESS
,
932 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
934 std::vector
<char> longkey
;
936 std::vector
<char>::iterator it
= longkey
.begin();
937 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
940 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
942 size_t string_length
;
944 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
945 test_compare(MEMCACHED_NOTFOUND
, rc
);
946 test_zero(string_length
);
948 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
949 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
950 test_zero(string_length
);
954 /* Make sure zero length keys are marked as bad */
956 test_compare(MEMCACHED_SUCCESS
,
957 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
958 size_t string_length
;
959 char *string
= memcached_get(memc_clone
, key
, 0,
960 &string_length
, &flags
, &rc
);
961 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
962 test_zero(string_length
);
966 memcached_free(memc_clone
);
971 #define READ_THROUGH_VALUE "set for me"
972 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
975 memcached_result_st
*result
)
977 (void)memc
;(void)key
;(void)key_length
;
978 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
981 #ifndef __INTEL_COMPILER
982 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
985 static test_return_t
read_through(memcached_st
*memc
)
987 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
989 size_t string_length
;
991 memcached_return_t rc
;
992 char *string
= memcached_get(memc
,
993 test_literal_param(__func__
),
994 &string_length
, &flags
, &rc
);
996 test_compare(MEMCACHED_NOTFOUND
, rc
);
997 test_false(string_length
);
1000 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
);
1001 test_compare(MEMCACHED_SUCCESS
, rc
);
1003 string
= memcached_get(memc
,
1004 test_literal_param(__func__
),
1005 &string_length
, &flags
, &rc
);
1007 test_compare(MEMCACHED_SUCCESS
, rc
);
1008 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1009 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1010 test_strcmp(READ_THROUGH_VALUE
, string
);
1013 string
= memcached_get(memc
,
1014 test_literal_param(__func__
),
1015 &string_length
, &flags
, &rc
);
1017 test_compare(MEMCACHED_SUCCESS
, rc
);
1019 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1020 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1021 test_strcmp(READ_THROUGH_VALUE
, string
);
1024 return TEST_SUCCESS
;
1027 static test_return_t
get_test(memcached_st
*memc
)
1029 memcached_return_t rc
;
1031 size_t string_length
;
1034 uint64_t query_id
= memcached_query_id(memc
);
1035 rc
= memcached_delete(memc
,
1036 test_literal_param(__func__
),
1038 test_true_got(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
, memcached_last_error_message(memc
));
1039 test_compare(query_id
+1, memcached_query_id(memc
));
1041 string
= memcached_get(memc
,
1042 test_literal_param(__func__
),
1043 &string_length
, &flags
, &rc
);
1045 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1046 test_false(string_length
);
1049 return TEST_SUCCESS
;
1052 static test_return_t
get_test2(memcached_st
*memc
)
1054 const char *value
= "when we sanitize";
1056 uint64_t query_id
= memcached_query_id(memc
);
1057 test_compare(return_value_based_on_buffering(memc
),
1059 test_literal_param(__func__
),
1060 value
, strlen(value
),
1061 time_t(0), uint32_t(0)));
1062 test_compare(query_id
+1, memcached_query_id(memc
));
1064 query_id
= memcached_query_id(memc
);
1065 test_true(query_id
);
1068 size_t string_length
;
1069 memcached_return_t rc
;
1070 char *string
= memcached_get(memc
,
1071 test_literal_param(__func__
),
1072 &string_length
, &flags
, &rc
);
1073 test_compare(query_id
+1, memcached_query_id(memc
));
1075 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1076 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1078 test_compare(strlen(value
), string_length
);
1079 test_memcmp(string
, value
, string_length
);
1083 return TEST_SUCCESS
;
1086 static test_return_t
set_test2(memcached_st
*memc
)
1088 for (uint32_t x
= 0; x
< 10; x
++)
1090 test_compare(return_value_based_on_buffering(memc
),
1092 test_literal_param("foo"),
1093 test_literal_param("train in the brain"),
1094 time_t(0), uint32_t(0)));
1097 return TEST_SUCCESS
;
1100 static test_return_t
set_test3(memcached_st
*memc
)
1102 size_t value_length
= 8191;
1104 std::vector
<char> value
;
1105 value
.reserve(value_length
);
1106 for (uint32_t x
= 0; x
< value_length
; x
++)
1108 value
.push_back(char(x
% 127));
1111 /* The dump test relies on there being at least 32 items in memcached */
1112 for (uint32_t x
= 0; x
< 32; x
++)
1116 snprintf(key
, sizeof(key
), "foo%u", x
);
1118 uint64_t query_id
= memcached_query_id(memc
);
1119 test_compare_hint(return_value_based_on_buffering(memc
),
1120 memcached_set(memc
, key
, strlen(key
),
1121 &value
[0], value
.size(),
1122 time_t(0), uint32_t(0)),
1123 memcached_last_error_message(memc
));
1124 test_compare(query_id
+1, memcached_query_id(memc
));
1127 return TEST_SUCCESS
;
1130 static test_return_t
get_test3(memcached_st
*memc
)
1132 size_t value_length
= 8191;
1134 std::vector
<char> value
;
1135 value
.reserve(value_length
);
1136 for (uint32_t x
= 0; x
< value_length
; x
++)
1138 value
.push_back(char(x
% 127));
1141 test_compare_hint(return_value_based_on_buffering(memc
),
1143 test_literal_param(__func__
),
1144 &value
[0], value
.size(),
1145 time_t(0), uint32_t(0)),
1146 memcached_last_error_message(memc
));
1148 size_t string_length
;
1150 memcached_return_t rc
;
1151 char *string
= memcached_get(memc
,
1152 test_literal_param(__func__
),
1153 &string_length
, &flags
, &rc
);
1155 test_compare(MEMCACHED_SUCCESS
, rc
);
1157 test_compare(value
.size(), string_length
);
1158 test_memcmp(string
, &value
[0], string_length
);
1162 return TEST_SUCCESS
;
1165 static test_return_t
get_test4(memcached_st
*memc
)
1167 size_t value_length
= 8191;
1169 std::vector
<char> value
;
1170 value
.reserve(value_length
);
1171 for (uint32_t x
= 0; x
< value_length
; x
++)
1173 value
.push_back(char(x
% 127));
1176 test_compare_hint(return_value_based_on_buffering(memc
),
1178 test_literal_param(__func__
),
1179 &value
[0], value
.size(),
1180 time_t(0), uint32_t(0)),
1181 memcached_last_error_message(memc
));
1183 for (uint32_t x
= 0; x
< 10; x
++)
1186 size_t string_length
;
1187 memcached_return_t rc
;
1188 char *string
= memcached_get(memc
,
1189 test_literal_param(__func__
),
1190 &string_length
, &flags
, &rc
);
1192 test_compare(MEMCACHED_SUCCESS
, rc
);
1194 test_compare(value
.size(), string_length
);
1195 test_memcmp(string
, &value
[0], string_length
);
1199 return TEST_SUCCESS
;
1203 * This test verifies that memcached_read_one_response doesn't try to
1204 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1205 * responses before you execute a storage command.
1207 static test_return_t
get_test5(memcached_st
*memc
)
1210 ** Request the same key twice, to ensure that we hash to the same server
1211 ** (so that we have multiple response values queued up) ;-)
1213 const char *keys
[]= { "key", "key" };
1214 size_t lengths
[]= { 3, 3 };
1218 test_compare_hint(return_value_based_on_buffering(memc
),
1219 memcached_set(memc
, keys
[0], lengths
[0],
1220 keys
[0], lengths
[0],
1221 time_t(0), uint32_t(0)),
1222 memcached_last_error_message(memc
));
1223 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1225 memcached_result_st results_obj
;
1226 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1229 memcached_return_t rc
;
1230 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1233 memcached_result_free(&results_obj
);
1235 /* Don't read out the second result, but issue a set instead.. */
1236 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1238 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1239 &rlen
, &flags
, &rc
);
1241 test_compare(MEMCACHED_NOTFOUND
, rc
);
1242 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1244 test_compare(MEMCACHED_SUCCESS
, rc
);
1247 return TEST_SUCCESS
;
1250 static test_return_t
mget_end(memcached_st
*memc
)
1252 const char *keys
[]= { "foo", "foo2" };
1253 size_t lengths
[]= { 3, 4 };
1254 const char *values
[]= { "fjord", "41" };
1256 memcached_return_t rc
;
1259 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1261 test_compare(MEMCACHED_SUCCESS
,
1263 keys
[x
], lengths
[x
],
1264 values
[x
], strlen(values
[x
]),
1265 time_t(0), uint32_t(0)));
1269 size_t string_length
;
1272 // retrieve both via mget
1273 test_compare(MEMCACHED_SUCCESS
,
1274 memcached_mget(memc
,
1276 test_array_length(keys
)));
1278 char key
[MEMCACHED_MAX_KEY
];
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 uint64_t new_number
;
1386 memcached_return_t rc
;
1387 const char *value
= "3";
1389 rc
= memcached_set(memc
,
1390 test_literal_param("number"),
1391 value
, strlen(value
),
1392 (time_t)0, (uint32_t)0);
1393 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1395 test_compare(MEMCACHED_SUCCESS
,
1396 memcached_decrement(memc
,
1397 test_literal_param("number"),
1399 test_compare(uint64_t(2), new_number
);
1401 test_compare(MEMCACHED_SUCCESS
,
1402 memcached_decrement(memc
,
1403 test_literal_param("number"),
1405 test_compare(uint64_t(1), new_number
);
1407 return TEST_SUCCESS
;
1410 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1412 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1414 uint64_t new_number
;
1415 uint64_t initial
= 3;
1417 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1419 test_compare(MEMCACHED_SUCCESS
,
1420 memcached_decrement_with_initial(memc
,
1421 test_literal_param("number"),
1422 1, initial
, 0, &new_number
));
1423 test_compare(new_number
, initial
);
1425 test_compare(MEMCACHED_SUCCESS
,
1426 memcached_decrement_with_initial(memc
,
1427 test_literal_param("number"),
1428 1, initial
, 0, &new_number
));
1429 test_compare(new_number
, (initial
- 1));
1431 return TEST_SUCCESS
;
1434 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1436 uint64_t new_number
;
1437 memcached_return_t rc
;
1438 const char *master_key
= "foo";
1439 const char *key
= "number";
1440 const char *value
= "0";
1442 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1444 value
, strlen(value
),
1445 (time_t)0, (uint32_t)0);
1446 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1448 test_compare(MEMCACHED_SUCCESS
,
1449 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1450 test_compare(uint64_t(1), new_number
);
1452 test_compare(MEMCACHED_SUCCESS
,
1453 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1454 test_compare(uint64_t(2), new_number
);
1456 return TEST_SUCCESS
;
1459 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1461 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1463 uint64_t new_number
;
1464 memcached_return_t rc
;
1465 const char *master_key
= "foo";
1466 const char *key
= "number";
1467 uint64_t initial
= 0;
1469 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1471 1, initial
, 0, &new_number
);
1472 test_compare(MEMCACHED_SUCCESS
, rc
);
1473 test_compare(new_number
, initial
);
1475 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1477 1, initial
, 0, &new_number
);
1478 test_compare(MEMCACHED_SUCCESS
, rc
);
1479 test_compare(new_number
, (initial
+1));
1481 return TEST_SUCCESS
;
1484 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1486 uint64_t new_number
;
1487 memcached_return_t rc
;
1488 const char *value
= "3";
1490 rc
= memcached_set_by_key(memc
,
1491 test_literal_param("foo"),
1492 test_literal_param("number"),
1493 value
, strlen(value
),
1494 (time_t)0, (uint32_t)0);
1495 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1497 test_compare(MEMCACHED_SUCCESS
,
1498 memcached_decrement_by_key(memc
,
1499 test_literal_param("foo"),
1500 test_literal_param("number"),
1502 test_compare(uint64_t(2), new_number
);
1504 test_compare(MEMCACHED_SUCCESS
,
1505 memcached_decrement_by_key(memc
,
1506 test_literal_param("foo"),
1507 test_literal_param("number"),
1509 test_compare(uint64_t(1), new_number
);
1511 return TEST_SUCCESS
;
1514 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1516 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1518 uint64_t new_number
;
1519 uint64_t initial
= 3;
1521 test_compare(MEMCACHED_SUCCESS
,
1522 memcached_decrement_with_initial_by_key(memc
,
1523 test_literal_param("foo"),
1524 test_literal_param("number"),
1525 1, initial
, 0, &new_number
));
1526 test_compare(new_number
, initial
);
1528 test_compare(MEMCACHED_SUCCESS
,
1529 memcached_decrement_with_initial_by_key(memc
,
1530 test_literal_param("foo"),
1531 test_literal_param("number"),
1532 1, initial
, 0, &new_number
));
1533 test_compare(new_number
, (initial
- 1));
1535 return TEST_SUCCESS
;
1537 static test_return_t
binary_increment_with_prefix_test(memcached_st
*orig_memc
)
1539 memcached_st
*memc
= memcached_clone(NULL
, orig_memc
);
1541 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1543 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1545 memcached_return_t rc
;
1546 rc
= memcached_set(memc
,
1547 test_literal_param("number"),
1548 test_literal_param("0"),
1549 (time_t)0, (uint32_t)0);
1550 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
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
);
1562 memcached_free(memc
);
1564 return TEST_SUCCESS
;
1567 static test_return_t
quit_test(memcached_st
*memc
)
1569 memcached_return_t rc
;
1570 const char *key
= "fudge";
1571 const char *value
= "sanford and sun";
1573 rc
= memcached_set(memc
, key
, strlen(key
),
1574 value
, strlen(value
),
1575 (time_t)10, (uint32_t)3);
1576 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1577 memcached_quit(memc
);
1579 rc
= memcached_set(memc
, key
, strlen(key
),
1580 value
, strlen(value
),
1581 (time_t)50, (uint32_t)9);
1582 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1584 return TEST_SUCCESS
;
1587 static test_return_t
mget_result_test(memcached_st
*memc
)
1589 const char *keys
[]= {"fudge", "son", "food"};
1590 size_t key_length
[]= {5, 3, 4};
1592 memcached_result_st results_obj
;
1593 memcached_result_st
*results
;
1595 results
= memcached_result_create(memc
, &results_obj
);
1597 test_true(&results_obj
== results
);
1599 /* We need to empty the server before continueing test */
1600 test_compare(MEMCACHED_SUCCESS
,
1601 memcached_flush(memc
, 0));
1603 test_compare(MEMCACHED_SUCCESS
,
1604 memcached_mget(memc
, keys
, key_length
, 3));
1606 memcached_return_t rc
;
1607 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1612 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1613 test_false(results
);
1614 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1616 for (uint32_t x
= 0; x
< 3; x
++)
1618 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1619 keys
[x
], key_length
[x
],
1620 (time_t)50, (uint32_t)9);
1621 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1624 test_compare(MEMCACHED_SUCCESS
,
1625 memcached_mget(memc
, keys
, key_length
, 3));
1627 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1630 test_true(&results_obj
== results
);
1631 test_compare(MEMCACHED_SUCCESS
, rc
);
1632 test_memcmp(memcached_result_key_value(results
),
1633 memcached_result_value(results
),
1634 memcached_result_length(results
));
1635 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1638 memcached_result_free(&results_obj
);
1640 return TEST_SUCCESS
;
1643 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1645 const char *keys
[]= {"fudge", "son", "food"};
1646 size_t key_length
[]= {5, 3, 4};
1648 memcached_result_st
*results
;
1650 /* We need to empty the server before continueing test */
1651 test_compare(MEMCACHED_SUCCESS
,
1652 memcached_flush(memc
, 0));
1654 test_compare(MEMCACHED_SUCCESS
,
1655 memcached_mget(memc
, keys
, key_length
, 3));
1657 memcached_return_t rc
;
1658 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1662 test_false(results
);
1663 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1665 for (uint32_t x
= 0; x
< 3; x
++)
1667 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1668 keys
[x
], key_length
[x
],
1669 (time_t)50, (uint32_t)9);
1670 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1673 test_compare(MEMCACHED_SUCCESS
,
1674 memcached_mget(memc
, keys
, key_length
, 3));
1677 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1680 test_compare(MEMCACHED_SUCCESS
, rc
);
1681 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1682 test_memcmp(memcached_result_key_value(results
),
1683 memcached_result_value(results
),
1684 memcached_result_length(results
));
1685 memcached_result_free(results
);
1689 return TEST_SUCCESS
;
1692 /* Count the results */
1693 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1695 size_t *counter
= (size_t *)context
;
1697 *counter
= *counter
+ 1;
1699 return MEMCACHED_SUCCESS
;
1702 static test_return_t
mget_result_function(memcached_st
*memc
)
1704 const char *keys
[]= {"fudge", "son", "food"};
1705 size_t key_length
[]= {5, 3, 4};
1707 memcached_execute_fn callbacks
[1];
1709 /* We need to empty the server before continueing test */
1710 test_compare(MEMCACHED_SUCCESS
,
1711 memcached_flush(memc
, 0));
1712 for (uint32_t x
= 0; x
< 3; x
++)
1714 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1715 keys
[x
], key_length
[x
],
1716 (time_t)50, (uint32_t)9);
1717 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1720 test_compare(MEMCACHED_SUCCESS
,
1721 memcached_mget(memc
, keys
, key_length
, 3));
1723 callbacks
[0]= &callback_counter
;
1726 test_compare(MEMCACHED_SUCCESS
,
1727 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1729 test_compare(size_t(3), counter
);
1731 return TEST_SUCCESS
;
1734 static test_return_t
mget_test(memcached_st
*memc
)
1736 const char *keys
[]= {"fudge", "son", "food"};
1737 size_t key_length
[]= {5, 3, 4};
1739 char return_key
[MEMCACHED_MAX_KEY
];
1740 size_t return_key_length
;
1742 size_t return_value_length
;
1744 /* We need to empty the server before continueing test */
1745 test_compare(MEMCACHED_SUCCESS
,
1746 memcached_flush(memc
, 0));
1748 test_compare(MEMCACHED_SUCCESS
,
1749 memcached_mget(memc
, keys
, key_length
, 3));
1752 memcached_return_t rc
;
1753 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1754 &return_value_length
, &flags
, &rc
)))
1756 test_true(return_value
);
1758 test_false(return_value
);
1759 test_zero(return_value_length
);
1760 test_compare(MEMCACHED_NOTFOUND
, rc
);
1762 for (uint32_t x
= 0; x
< 3; x
++)
1764 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1765 keys
[x
], key_length
[x
],
1766 (time_t)50, (uint32_t)9);
1767 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1769 test_compare(MEMCACHED_SUCCESS
,
1770 memcached_mget(memc
, keys
, key_length
, 3));
1773 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1774 &return_value_length
, &flags
, &rc
)))
1776 test_true(return_value
);
1777 test_compare(MEMCACHED_SUCCESS
, rc
);
1778 if (not memc
->_namespace
)
1780 test_compare(return_key_length
, return_value_length
);
1781 test_memcmp(return_value
, return_key
, return_value_length
);
1787 return TEST_SUCCESS
;
1790 static test_return_t
mget_execute(memcached_st
*original_memc
)
1792 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1794 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1797 size_t max_keys
= 20480;
1800 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1801 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1803 /* First add all of the items.. */
1804 char blob
[1024] = {0};
1806 for (size_t x
= 0; x
< max_keys
; ++x
)
1810 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1812 test_true(keys
[x
] != NULL
);
1813 uint64_t query_id
= memcached_query_id(memc
);
1814 memcached_return_t rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1815 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1816 test_compare(query_id
+1, memcached_query_id(memc
));
1819 /* Try to get all of them with a large multiget */
1821 memcached_execute_fn callbacks
[]= { &callback_counter
};
1822 test_compare(MEMCACHED_SUCCESS
,
1823 memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1824 max_keys
, callbacks
, &counter
, 1));
1827 uint64_t query_id
= memcached_query_id(memc
);
1828 test_compare(MEMCACHED_SUCCESS
,
1829 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1830 test_compare(query_id
, memcached_query_id(memc
));
1832 /* Verify that we got all of the items */
1833 test_true(counter
== max_keys
);
1836 /* Release all allocated resources */
1837 for (size_t x
= 0; x
< max_keys
; ++x
)
1844 memcached_free(memc
);
1846 return TEST_SUCCESS
;
1849 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1851 static test_return_t
key_setup(memcached_st
*memc
)
1853 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1855 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1857 return TEST_SUCCESS
;
1860 static test_return_t
key_teardown(memcached_st
*memc
)
1863 pairs_free(global_pairs
);
1865 return TEST_SUCCESS
;
1868 static test_return_t
block_add_regression(memcached_st
*memc
)
1870 /* First add all of the items.. */
1871 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1873 char blob
[1024] = {0};
1875 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);
1876 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
, memcached_strerror(NULL
, rc
));
1879 return TEST_SUCCESS
;
1882 static test_return_t
binary_add_regression(memcached_st
*memc
)
1884 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1885 test_return_t rc
= block_add_regression(memc
);
1890 static test_return_t
get_stats_keys(memcached_st
*memc
)
1894 memcached_stat_st memc_stat
;
1895 memcached_return_t rc
;
1897 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1898 test_compare(MEMCACHED_SUCCESS
, rc
);
1899 for (ptr
= stat_list
; *ptr
; ptr
++)
1904 return TEST_SUCCESS
;
1907 static test_return_t
version_string_test(memcached_st
*)
1909 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1911 return TEST_SUCCESS
;
1914 static test_return_t
get_stats(memcached_st
*memc
)
1916 memcached_return_t rc
;
1918 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1919 test_compare(MEMCACHED_SUCCESS
, rc
);
1920 test_true(memc_stat
);
1922 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1924 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1925 test_compare(MEMCACHED_SUCCESS
, rc
);
1926 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1931 memcached_stat_free(NULL
, memc_stat
);
1933 return TEST_SUCCESS
;
1936 static test_return_t
add_host_test(memcached_st
*memc
)
1938 char servername
[]= "0.example.com";
1940 memcached_return_t rc
;
1941 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1942 test_compare(1U, memcached_server_list_count(servers
));
1944 for (unsigned int x
= 2; x
< 20; x
++)
1946 char buffer
[SMALL_STRING_LEN
];
1948 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1949 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1951 test_compare(MEMCACHED_SUCCESS
, rc
);
1952 test_compare(x
, memcached_server_list_count(servers
));
1955 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1956 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1958 memcached_server_list_free(servers
);
1960 return TEST_SUCCESS
;
1963 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1965 memcached_return_t rc
;
1967 const char *key
= "not_found";
1968 size_t key_length
= test_literal_param_size("not_found");
1970 test_compare(MEMCACHED_SUCCESS
,
1971 memcached_mget(memc
, &key
, &key_length
, 1));
1973 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1975 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1977 memcached_result_free(result
);
1979 return TEST_SUCCESS
;
1982 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1984 return MEMCACHED_SUCCESS
;
1987 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1989 return MEMCACHED_SUCCESS
;
1992 static test_return_t
callback_test(memcached_st
*memc
)
1994 /* Test User Data */
1998 memcached_return_t rc
;
2000 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
2001 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
2002 test_true(*test_ptr
== x
);
2005 /* Test Clone Callback */
2007 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2008 void *clone_cb_ptr
= *(void **)&clone_cb
;
2009 void *temp_function
= NULL
;
2011 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
2012 memcached_return_t rc
;
2013 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2014 test_true(temp_function
== clone_cb_ptr
);
2015 test_compare(MEMCACHED_SUCCESS
, rc
);
2018 /* Test Cleanup Callback */
2020 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2021 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2022 void *temp_function
= NULL
;
2023 memcached_return_t rc
;
2025 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2026 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2027 test_true(temp_function
== cleanup_cb_ptr
);
2030 return TEST_SUCCESS
;
2033 /* We don't test the behavior itself, we test the switches */
2034 static test_return_t
behavior_test(memcached_st
*memc
)
2036 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2037 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2039 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2040 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2042 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2043 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2045 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2046 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2048 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2049 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2051 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2052 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2054 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2055 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2057 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2059 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2061 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2062 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2063 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2065 return TEST_SUCCESS
;
2068 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2070 test_compare(MEMCACHED_DEPRECATED
,
2071 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2073 // Platform dependent
2075 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2079 return TEST_SUCCESS
;
2083 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2085 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2086 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2088 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2090 if (memcached_success(rc
))
2099 return TEST_SUCCESS
;
2103 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2105 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2106 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2108 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2110 if (memcached_success(rc
))
2119 return TEST_SUCCESS
;
2122 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, const memcached_return_t expect
)
2124 memcached_return_t rc
;
2125 char return_key
[MEMCACHED_MAX_KEY
];
2126 size_t return_key_length
;
2128 size_t return_value_length
;
2132 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2133 &return_value_length
, &flags
, &rc
)))
2135 test_true(return_value
);
2136 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2141 if (memcached_success(expect
) and memcached_success(rc
))
2143 return TEST_SUCCESS
;
2145 else if (expect
== rc
)
2147 return TEST_SUCCESS
;
2149 fprintf(stderr
, "\n%s:%u %s(#%u)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), keys_returned
);
2151 return TEST_FAILURE
;
2154 /* Test case provided by Cal Haldenbrand */
2155 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2156 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2157 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2159 /* We just keep looking at the same values over and over */
2162 test_compare(MEMCACHED_SUCCESS
,
2163 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2164 test_compare(MEMCACHED_SUCCESS
,
2165 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2169 unsigned long long total
= 0;
2170 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2172 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2173 char randomstuff
[6 * 1024];
2174 memset(randomstuff
, 0, 6 * 1024);
2175 test_true(size
< 6 * 1024); /* Being safe here */
2177 for (uint32_t j
= 0 ; j
< size
;j
++)
2179 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2184 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2185 test_compare(MEMCACHED_SUCCESS
,
2186 memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
));
2188 test_true(total
> HALDENBRAND_KEY_COUNT
);
2190 return TEST_SUCCESS
;
2193 /* Test case provided by Cal Haldenbrand */
2194 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2196 test_compare(MEMCACHED_SUCCESS
,
2197 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2199 test_compare(MEMCACHED_SUCCESS
,
2200 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2203 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576));
2204 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576));
2205 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2206 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2208 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2211 size_t total_value_length
= 0;
2212 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2217 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2218 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2220 memcached_return_t rc
;
2221 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2222 if (memcached_failed(rc
))
2224 if (rc
== MEMCACHED_NOTFOUND
)
2235 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2237 total_value_length
+= val_len
;
2242 return TEST_SUCCESS
;
2245 /* Do a large mget() over all the keys we think exist */
2246 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2248 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
2249 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
2252 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576);
2253 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576);
2254 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2255 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2258 std::vector
<size_t> key_lengths
;
2259 key_lengths
.resize(HALDENBRAND_KEY_COUNT
);
2260 std::vector
<char *> keys
;
2261 keys
.resize(key_lengths
.size());
2262 for (uint32_t x
= 0; x
< key_lengths
.size(); x
++)
2264 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2265 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2266 test_true(key_length
> 0 and key_length
< MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1);
2267 keys
[x
]= strdup(key
);
2268 key_lengths
[x
]= key_length
;
2271 test_compare(MEMCACHED_SUCCESS
,
2272 memcached_mget(memc
, &keys
[0], &key_lengths
[0], key_lengths
.size()));
2274 unsigned int keys_returned
;
2275 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
2276 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2278 for (std::vector
<char *>::iterator iter
= keys
.begin();
2285 return TEST_SUCCESS
;
2288 /* Make sure we behave properly if server list has no values */
2289 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2291 const char *keys
[]= {"fudge", "son", "food"};
2292 size_t key_length
[]= {5, 3, 4};
2294 /* Here we free everything before running a bunch of mget tests */
2295 memcached_servers_reset(memc
);
2298 /* We need to empty the server before continueing test */
2299 test_compare(MEMCACHED_NO_SERVERS
,
2300 memcached_flush(memc
, 0));
2302 test_compare(MEMCACHED_NO_SERVERS
,
2303 memcached_mget(memc
, keys
, key_length
, 3));
2305 unsigned int keys_returned
;
2306 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2307 test_zero(keys_returned
);
2309 for (uint32_t x
= 0; x
< 3; x
++)
2311 test_compare(MEMCACHED_NO_SERVERS
,
2312 memcached_set(memc
, keys
[x
], key_length
[x
],
2313 keys
[x
], key_length
[x
],
2314 (time_t)50, (uint32_t)9));
2317 test_compare(MEMCACHED_NO_SERVERS
,
2318 memcached_mget(memc
, keys
, key_length
, 3));
2322 char return_key
[MEMCACHED_MAX_KEY
];
2323 memcached_return_t rc
;
2324 size_t return_key_length
;
2325 size_t return_value_length
;
2328 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2329 &return_value_length
, &flags
, &rc
)))
2331 test_true(return_value
);
2332 test_compare(MEMCACHED_SUCCESS
, rc
);
2333 test_true(return_key_length
== return_value_length
);
2334 test_memcmp(return_value
, return_key
, return_value_length
);
2340 return TEST_SUCCESS
;
2343 #define VALUE_SIZE_BUG5 1048064
2344 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2346 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2347 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2349 size_t value_length
;
2351 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2353 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2355 insert_data
[x
]= (signed char)rand();
2358 test_compare(MEMCACHED_SUCCESS
,
2359 memcached_flush(memc
, 0));
2361 memcached_return_t rc
;
2362 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2363 test_compare(MEMCACHED_SUCCESS
,
2364 memcached_mget(memc
, keys
, key_length
, 4));
2367 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2370 for (uint32_t x
= 0; x
< 4; x
++)
2372 test_compare(MEMCACHED_SUCCESS
,
2373 memcached_set(memc
, keys
[x
], key_length
[x
],
2374 insert_data
, VALUE_SIZE_BUG5
,
2375 (time_t)0, (uint32_t)0));
2378 for (uint32_t x
= 0; x
< 10; x
++)
2380 value
= memcached_get(memc
, keys
[0], key_length
[0],
2381 &value_length
, &flags
, &rc
);
2382 test_compare(rc
, MEMCACHED_SUCCESS
);
2386 test_compare(MEMCACHED_SUCCESS
,
2387 memcached_mget(memc
, keys
, key_length
, 4));
2389 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2390 test_compare(4U, count
);
2392 delete [] insert_data
;
2394 return TEST_SUCCESS
;
2397 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2399 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2400 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2401 char return_key
[MEMCACHED_MAX_KEY
];
2402 size_t return_key_length
;
2404 size_t value_length
;
2406 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2408 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2410 insert_data
[x
]= (signed char)rand();
2413 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2415 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2417 // We will now confirm that memcached_mget() returns success, but we will
2418 // then check to make sure that no actual keys are returned.
2419 test_compare(MEMCACHED_SUCCESS
,
2420 memcached_mget(memc
, keys
, key_length
, 4));
2422 memcached_return_t rc
;
2424 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2425 &value_length
, &flags
, &rc
)))
2430 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2432 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2434 test_compare(MEMCACHED_SUCCESS
,
2435 memcached_set(memc
, keys
[x
], key_length
[x
],
2436 insert_data
, VALUE_SIZE_BUG5
,
2437 (time_t)0, (uint32_t)0));
2439 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2441 for (uint32_t x
= 0; x
< 2; x
++)
2443 value
= memcached_get(memc
, keys
[0], key_length
[0],
2444 &value_length
, &flags
, &rc
);
2448 test_compare(MEMCACHED_SUCCESS
,
2449 memcached_mget(memc
, keys
, key_length
, 4));
2450 /* We test for purge of partial complete fetches */
2451 for (count
= 3; count
; count
--)
2453 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2454 &value_length
, &flags
, &rc
);
2455 test_compare(MEMCACHED_SUCCESS
, rc
);
2456 test_memcmp(value
, insert_data
, value_length
);
2457 test_true(value_length
);
2461 delete [] insert_data
;
2463 return TEST_SUCCESS
;
2466 static test_return_t
user_supplied_bug8(memcached_st
*)
2468 memcached_return_t rc
;
2470 memcached_st
*memc_clone
;
2472 memcached_server_st
*servers
;
2473 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";
2475 servers
= memcached_servers_parse(server_list
);
2478 mine
= memcached_create(NULL
);
2479 rc
= memcached_server_push(mine
, servers
);
2480 test_compare(MEMCACHED_SUCCESS
, rc
);
2481 memcached_server_list_free(servers
);
2484 memc_clone
= memcached_clone(NULL
, mine
);
2486 memcached_quit(mine
);
2487 memcached_quit(memc_clone
);
2490 memcached_free(mine
);
2491 memcached_free(memc_clone
);
2493 return TEST_SUCCESS
;
2496 /* Test flag store/retrieve */
2497 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2499 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2500 test_true(insert_data
);
2502 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2504 insert_data
[x
]= (signed char)rand();
2507 memcached_flush(memc
, 0);
2509 const char *keys
= "036790384900";
2510 size_t key_length
= strlen(keys
);
2511 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2512 insert_data
, VALUE_SIZE_BUG5
,
2514 memcached_last_error_message(memc
));
2516 memcached_return_t rc
;
2517 size_t value_length
;
2519 char *value
= memcached_get(memc
, keys
, key_length
,
2520 &value_length
, &flags
, &rc
);
2521 test_compare(245U, flags
);
2525 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2527 char return_key
[MEMCACHED_MAX_KEY
];
2528 size_t return_key_length
;
2530 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2531 &value_length
, &flags
, &rc
);
2532 test_compare(uint32_t(245), flags
);
2535 delete [] insert_data
;
2538 return TEST_SUCCESS
;
2541 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2543 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2544 size_t key_length
[3];
2548 char return_key
[MEMCACHED_MAX_KEY
];
2549 size_t return_key_length
;
2551 size_t return_value_length
;
2554 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2555 key_length
[1]= strlen("fudge&*@#");
2556 key_length
[2]= strlen("for^#@&$not");
2559 for (unsigned int x
= 0; x
< 3; x
++)
2561 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2562 keys
[x
], key_length
[x
],
2563 (time_t)50, (uint32_t)9);
2564 test_compare(MEMCACHED_SUCCESS
, rc
);
2567 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2568 test_compare(MEMCACHED_SUCCESS
, rc
);
2570 /* We need to empty the server before continueing test */
2571 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2572 &return_value_length
, &flags
, &rc
)) != NULL
)
2574 test_true(return_value
);
2578 test_compare(3U, count
);
2580 return TEST_SUCCESS
;
2583 /* We are testing with aggressive timeout to get failures */
2584 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2586 size_t value_length
= 512;
2587 unsigned int set
= 1;
2588 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2590 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2591 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2592 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2594 std::vector
<char> value
;
2595 value
.reserve(value_length
);
2596 for (uint32_t x
= 0; x
< value_length
; x
++)
2598 value
.push_back(char(x
% 127));
2601 for (unsigned int x
= 1; x
<= 100000; ++x
)
2603 memcached_return_t rc
= memcached_set(mclone
,
2604 test_literal_param("foo"),
2605 &value
[0], value
.size(),
2608 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2609 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2610 memcached_strerror(NULL
, rc
));
2612 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2618 memcached_free(mclone
);
2620 return TEST_SUCCESS
;
2624 We are looking failures in the async protocol
2626 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2628 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2630 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2631 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2632 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2634 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2637 std::vector
<char> value
;
2639 for (unsigned int x
= 0; x
< 512; x
++)
2641 value
.push_back(char(x
% 127));
2644 for (unsigned int x
= 1; x
<= 100000; ++x
)
2646 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2650 memcached_free(mclone
);
2652 return TEST_SUCCESS
;
2656 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2658 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2660 memcached_return_t rc
;
2662 size_t value_length
;
2664 uint64_t number_value
;
2666 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2667 &value_length
, &flags
, &rc
);
2669 test_compare(MEMCACHED_NOTFOUND
, rc
);
2671 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2674 /* The binary protocol will set the key if it doesn't exist */
2675 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2677 test_compare(MEMCACHED_SUCCESS
, rc
);
2681 test_compare(MEMCACHED_NOTFOUND
, rc
);
2684 test_compare(MEMCACHED_SUCCESS
,
2685 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2687 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2691 test_compare(MEMCACHED_SUCCESS
,
2692 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2693 test_compare(2UL, number_value
);
2695 return TEST_SUCCESS
;
2699 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2700 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2702 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2704 char key
[] = "key34567890";
2705 memcached_return_t rc
;
2706 size_t overflowSize
;
2708 char commandFirst
[]= "set key34567890 0 0 ";
2709 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2710 size_t commandLength
;
2713 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2715 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2717 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2719 char *overflow
= new (std::nothrow
) char[testSize
];
2720 test_true(overflow
);
2722 memset(overflow
, 'x', testSize
);
2723 rc
= memcached_set(memc
, key
, strlen(key
),
2724 overflow
, testSize
, 0, 0);
2725 test_compare(MEMCACHED_SUCCESS
, rc
);
2729 return TEST_SUCCESS
;
2734 Test values of many different sizes
2735 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2736 set key34567890 0 0 8169 \r\n
2737 is sent followed by buffer of size 8169, followed by 8169
2739 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2741 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2743 std::vector
<char> value
;
2744 value
.reserve(18000);
2745 for (size_t x
= 0; x
< 18000; x
++)
2747 value
.push_back((char) (x
% 127));
2750 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2752 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2753 &value
[0], current_length
,
2754 (time_t)0, (uint32_t)0);
2755 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2757 size_t string_length
;
2759 char *string
= memcached_get(memc
, test_literal_param("foo"),
2760 &string_length
, &flags
, &rc
);
2762 test_compare(MEMCACHED_SUCCESS
, rc
);
2763 test_compare(string_length
, current_length
);
2764 test_memcmp(string
, &value
[0], string_length
);
2769 return TEST_SUCCESS
;
2773 Look for zero length value problems
2775 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2777 for (uint32_t x
= 0; x
< 2; x
++)
2779 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2781 (time_t)0, (uint32_t)0);
2783 test_compare(MEMCACHED_SUCCESS
, rc
);
2787 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2788 &length
, &flags
, &rc
);
2790 test_compare(MEMCACHED_SUCCESS
, rc
);
2795 value
= memcached_get(memc
, test_literal_param("mykey"),
2796 &length
, &flags
, &rc
);
2798 test_compare(MEMCACHED_SUCCESS
, rc
);
2799 test_true(value
== NULL
);
2804 return TEST_SUCCESS
;
2807 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2808 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2810 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2812 (time_t)0, UINT32_MAX
),
2813 memcached_last_error_message(memc
));
2818 memcached_return_t rc
;
2819 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2820 &length
, &flags
, &rc
);
2822 test_compare(MEMCACHED_SUCCESS
, rc
);
2825 test_compare(flags
, UINT32_MAX
);
2827 return TEST_SUCCESS
;
2830 #if !defined(__sun) && !defined(__OpenBSD__)
2831 /* Check the validity of chinese key*/
2832 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2834 const char *key
= "豆瓣";
2835 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2836 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2837 value
, strlen(value
),
2840 test_compare(MEMCACHED_SUCCESS
, rc
);
2844 char *value2
= memcached_get(memc
, key
, strlen(key
),
2845 &length
, &flags
, &rc
);
2847 test_true(length
==strlen(value
));
2848 test_compare(MEMCACHED_SUCCESS
, rc
);
2849 test_memcmp(value
, value2
, length
);
2852 return TEST_SUCCESS
;
2860 static test_return_t
user_supplied_bug19(memcached_st
*)
2862 memcached_return_t res
;
2864 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2866 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2869 memcached_free(memc
);
2871 return TEST_SUCCESS
;
2874 /* CAS test from Andei */
2875 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2877 const char *key
= "abc";
2878 size_t key_len
= strlen("abc");
2880 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2882 test_compare(MEMCACHED_SUCCESS
,
2884 test_literal_param("abc"),
2885 test_literal_param("foobar"),
2886 (time_t)0, (uint32_t)0));
2888 test_compare(MEMCACHED_SUCCESS
,
2889 memcached_mget(memc
, &key
, &key_len
, 1));
2891 memcached_result_st result_obj
;
2892 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2895 memcached_result_create(memc
, &result_obj
);
2896 memcached_return_t status
;
2897 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2900 test_compare(MEMCACHED_SUCCESS
, status
);
2902 memcached_result_free(result
);
2904 return TEST_SUCCESS
;
2907 /* Large mget() of missing keys with binary proto
2909 * If many binary quiet commands (such as getq's in an mget) fill the output
2910 * buffer and the server chooses not to respond, memcached_flush hangs. See
2911 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2914 /* sighandler_t function that always asserts false */
2915 static void fail(int)
2921 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2926 return TEST_SKIPPED
;
2928 void (*oldalarm
)(int);
2930 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2931 test_true(memc_clone
);
2933 /* only binproto uses getq for mget */
2934 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2936 /* empty the cache to ensure misses (hence non-responses) */
2937 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2939 std::vector
<size_t> key_lengths
;
2940 key_lengths
.resize(key_count
);
2941 std::vector
<char *> keys
;
2942 keys
.resize(key_lengths
.size());
2943 for (unsigned int x
= 0; x
< key_lengths
.size(); x
++)
2945 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2946 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2947 test_true(key_length
> 0 and key_length
< MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1);
2948 keys
[x
]= strdup(key
);
2949 key_lengths
[x
]= key_length
;
2952 oldalarm
= signal(SIGALRM
, fail
);
2955 test_compare_got(MEMCACHED_SUCCESS
,
2956 memcached_mget(memc_clone
, &keys
[0], &key_lengths
[0], key_count
), memcached_last_error_message(memc_clone
));
2959 signal(SIGALRM
, oldalarm
);
2961 memcached_return_t rc
;
2963 char return_key
[MEMCACHED_MAX_KEY
];
2964 size_t return_key_length
;
2966 size_t return_value_length
;
2967 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2968 &return_value_length
, &flags
, &rc
)))
2970 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2972 test_compare(MEMCACHED_NOTFOUND
, rc
);
2973 test_zero(return_value_length
);
2974 test_zero(return_key_length
);
2975 test_false(return_key
[0]);
2976 test_false(return_value
);
2978 for (std::vector
<char *>::iterator iter
= keys
.begin();
2985 memcached_free(memc_clone
);
2987 return TEST_SUCCESS
;
2991 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
2993 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2995 /* should work as of r580 */
2996 test_compare(TEST_SUCCESS
,
2997 _user_supplied_bug21(memc
, 10));
2999 /* should fail as of r580 */
3000 test_compare(TEST_SUCCESS
,
3001 _user_supplied_bug21(memc
, 1000));
3003 return TEST_SUCCESS
;
3006 static test_return_t
output_ketama_weighted_keys(memcached_st
*)
3008 memcached_st
*memc
= memcached_create(NULL
);
3012 test_compare(MEMCACHED_SUCCESS
,
3013 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
3015 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3016 test_compare(value
, uint64_t(1));
3018 test_compare(MEMCACHED_SUCCESS
,
3019 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3021 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3022 test_true(value
== MEMCACHED_HASH_MD5
);
3025 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3027 memcached_server_st
*server_pool
;
3028 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");
3029 memcached_server_push(memc
, server_pool
);
3031 // @todo this needs to be refactored to actually test something.
3034 if ((fp
= fopen("ketama_keys.txt", "w")))
3038 printf("cannot write to file ketama_keys.txt");
3039 return TEST_FAILURE
;
3042 for (int x
= 0; x
< 10000; x
++)
3045 snprintf(key
, sizeof(key
), "%d", x
);
3047 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3048 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3049 in_port_t port
= memc
->hosts
[server_idx
].port
;
3050 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3051 memcached_server_instance_st instance
=
3052 memcached_server_instance_by_position(memc
, host_index
);
3056 memcached_server_list_free(server_pool
);
3057 memcached_free(memc
);
3059 return TEST_SUCCESS
;
3063 static test_return_t
result_static(memcached_st
*memc
)
3065 memcached_result_st result
;
3066 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3067 test_false(result
.options
.is_allocated
);
3068 test_true(memcached_is_initialized(&result
));
3069 test_true(result_ptr
);
3070 test_true(result_ptr
== &result
);
3072 memcached_result_free(&result
);
3074 test_false(result
.options
.is_allocated
);
3075 test_false(memcached_is_initialized(&result
));
3077 return TEST_SUCCESS
;
3080 static test_return_t
result_alloc(memcached_st
*memc
)
3082 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3083 test_true(result_ptr
);
3084 test_true(result_ptr
->options
.is_allocated
);
3085 test_true(memcached_is_initialized(result_ptr
));
3086 memcached_result_free(result_ptr
);
3088 return TEST_SUCCESS
;
3091 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3094 pairs_free(global_pairs
);
3096 return TEST_SUCCESS
;
3099 static test_return_t
generate_pairs(memcached_st
*)
3101 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3102 global_count
= GLOBAL_COUNT
;
3104 for (size_t x
= 0; x
< global_count
; x
++)
3106 global_keys
[x
]= global_pairs
[x
].key
;
3107 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3110 return TEST_SUCCESS
;
3113 static test_return_t
generate_large_pairs(memcached_st
*)
3115 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3116 global_count
= GLOBAL2_COUNT
;
3118 for (size_t x
= 0; x
< global_count
; x
++)
3120 global_keys
[x
]= global_pairs
[x
].key
;
3121 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3124 return TEST_SUCCESS
;
3127 static test_return_t
generate_data(memcached_st
*memc
)
3129 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3131 test_compare(global_count
, check_execute
);
3133 return TEST_SUCCESS
;
3136 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3138 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3140 test_compare(check_execute
, global_count
);
3142 // @todo hosts used size stats
3143 memcached_return_t rc
;
3144 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3147 for (uint32_t host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3149 /* This test was changes so that "make test" would work properlly */
3152 memcached_server_instance_st instance
=
3153 memcached_server_instance_by_position(memc
, host_index
);
3155 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3157 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3160 memcached_stat_free(NULL
, stat_p
);
3162 return TEST_SUCCESS
;
3164 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3166 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3167 generate_data(memc
);
3169 return TEST_SUCCESS
;
3172 static test_return_t
get_read_count(memcached_st
*memc
)
3174 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3175 test_true(memc_clone
);
3177 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3181 size_t return_value_length
;
3185 for (size_t x
= count
= 0; x
< global_count
; x
++)
3187 memcached_return_t rc
;
3188 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3189 &return_value_length
, &flags
, &rc
);
3190 if (rc
== MEMCACHED_SUCCESS
)
3201 memcached_free(memc_clone
);
3203 return TEST_SUCCESS
;
3206 static test_return_t
get_read(memcached_st
*memc
)
3208 for (size_t x
= 0; x
< global_count
; x
++)
3210 size_t return_value_length
;
3212 memcached_return_t rc
;
3213 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3214 &return_value_length
, &flags
, &rc
);
3216 test_true(return_value);
3217 test_compare(MEMCACHED_SUCCESS, rc);
3219 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3225 return TEST_SUCCESS
;
3228 static test_return_t
mget_read(memcached_st
*memc
)
3231 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3233 test_compare(MEMCACHED_SUCCESS
,
3234 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3236 // Go fetch the keys and test to see if all of them were returned
3238 unsigned int keys_returned
;
3239 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3240 test_true(keys_returned
> 0);
3241 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3244 return TEST_SUCCESS
;
3247 static test_return_t
mget_read_result(memcached_st
*memc
)
3250 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3252 test_compare(MEMCACHED_SUCCESS
,
3253 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3255 /* Turn this into a help function */
3257 memcached_result_st results_obj
;
3258 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3261 memcached_return_t rc
;
3262 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3264 if (rc
== MEMCACHED_IN_PROGRESS
)
3270 test_compare(MEMCACHED_SUCCESS
, rc
);
3272 test_compare(MEMCACHED_END
, rc
);
3274 memcached_result_free(&results_obj
);
3277 return TEST_SUCCESS
;
3280 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3283 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3285 test_compare(MEMCACHED_SUCCESS
,
3286 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3288 memcached_result_st
*results
= NULL
;
3289 memcached_return_t rc
;
3290 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3293 test_compare(MEMCACHED_SUCCESS
, rc
);
3295 test_compare(MEMCACHED_END
, rc
);
3297 memcached_result_free(results
);
3300 return TEST_SUCCESS
;
3303 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3306 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3308 test_compare(MEMCACHED_SUCCESS
,
3309 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3311 // We will scan for just one key
3313 memcached_result_st results_obj
;
3314 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3316 memcached_return_t rc
;
3317 results
= memcached_fetch_result(memc
, results
, &rc
);
3319 test_compare(MEMCACHED_SUCCESS
, rc
);
3321 memcached_result_free(&results_obj
);
3324 // We already have a read happening, lets start up another one.
3325 test_compare(MEMCACHED_SUCCESS
,
3326 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3328 memcached_result_st results_obj
;
3329 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3331 test_false(memcached_is_allocated(results
));
3333 memcached_return_t rc
;
3334 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3337 test_compare(MEMCACHED_SUCCESS
, rc
);
3339 test_compare(MEMCACHED_END
, rc
);
3341 memcached_result_free(&results_obj
);
3344 return TEST_SUCCESS
;
3347 static test_return_t
mget_read_function(memcached_st
*memc
)
3349 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3351 test_compare(MEMCACHED_SUCCESS
,
3352 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3354 memcached_execute_fn callbacks
[]= { &callback_counter
};
3356 test_compare(MEMCACHED_SUCCESS
,
3357 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3359 return TEST_SUCCESS
;
3362 static test_return_t
delete_generate(memcached_st
*memc
)
3364 for (size_t x
= 0; x
< global_count
; x
++)
3366 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3369 return TEST_SUCCESS
;
3372 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3374 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3376 for (size_t x
= 0; x
< global_count
; x
++)
3378 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3381 return TEST_SUCCESS
;
3384 static test_return_t
add_host_test1(memcached_st
*memc
)
3386 memcached_return_t rc
;
3387 char servername
[]= "0.example.com";
3389 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3391 test_compare(1U, memcached_server_list_count(servers
));
3393 for (uint32_t x
= 2; x
< 20; x
++)
3395 char buffer
[SMALL_STRING_LEN
];
3397 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3398 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3400 test_compare(MEMCACHED_SUCCESS
, rc
);
3401 test_compare(x
, memcached_server_list_count(servers
));
3404 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3405 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3407 memcached_server_list_free(servers
);
3409 return TEST_SUCCESS
;
3412 static test_return_t
pre_nonblock(memcached_st
*memc
)
3414 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3416 return TEST_SUCCESS
;
3419 static test_return_t
pre_cork(memcached_st
*memc
)
3422 return TEST_SKIPPED
;
3425 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3426 return TEST_SUCCESS
;
3428 return TEST_SKIPPED
;
3431 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3434 return TEST_SKIPPED
;
3436 test_return_t test_rc
;
3437 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3440 return pre_nonblock(memc
);
3443 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3445 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3446 test_true(memc_clone
);
3448 // The memcached_version needs to be done on a clone, because the server
3449 // will not toggle protocol on an connection.
3450 memcached_version(memc_clone
);
3452 memcached_return_t rc
= MEMCACHED_FAILURE
;
3453 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3455 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3456 test_compare(MEMCACHED_SUCCESS
,
3457 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3458 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3462 memcached_free(memc_clone
);
3463 return TEST_SKIPPED
;
3466 memcached_free(memc_clone
);
3468 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3471 static test_return_t
pre_murmur(memcached_st
*memc
)
3473 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3474 return TEST_SUCCESS
;
3477 static test_return_t
pre_jenkins(memcached_st
*memc
)
3479 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3481 return TEST_SKIPPED
;
3485 static test_return_t
pre_md5(memcached_st
*memc
)
3487 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3489 return TEST_SUCCESS
;
3492 static test_return_t
pre_crc(memcached_st
*memc
)
3494 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3496 return TEST_SUCCESS
;
3499 static test_return_t
pre_hsieh(memcached_st
*memc
)
3501 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
));
3502 return TEST_SUCCESS
;
3505 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3507 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3509 return TEST_SUCCESS
;
3512 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3514 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
));
3516 return TEST_SUCCESS
;
3519 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3521 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3523 return TEST_SUCCESS
;
3526 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3528 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3530 return TEST_SUCCESS
;
3533 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3535 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3536 test_compare(MEMCACHED_SUCCESS
, rc
);
3538 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3539 test_compare(value
, uint64_t(1));
3541 return TEST_SUCCESS
;
3544 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3546 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3547 test_compare(MEMCACHED_SUCCESS
, rc
);
3549 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3550 test_compare(value
, uint64_t(1));
3552 test_compare(MEMCACHED_SUCCESS
,
3553 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3555 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3556 test_compare(MEMCACHED_HASH_MD5
, memcached_hash_t(value
));
3558 return TEST_SUCCESS
;
3561 static test_return_t
pre_replication(memcached_st
*memc
)
3563 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3566 * Make sure that we store the item on all servers
3567 * (master + replicas == number of servers)
3569 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3570 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3572 return TEST_SUCCESS
;
3576 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3578 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3580 return pre_nonblock(memc
);
3584 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3588 #ifdef HARD_MALLOC_TESTS
3589 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3597 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3601 #ifdef HARD_MALLOC_TESTS
3602 void *ret
= malloc(size
+ 8);
3605 ret
= (void*)((caddr_t
)ret
+ 8);
3608 void *ret
= malloc(size
);
3613 memset(ret
, 0xff, size
);
3620 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3622 #ifdef HARD_MALLOC_TESTS
3623 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3624 void *nmem
= realloc(real_ptr
, size
+ 8);
3629 ret
= (void*)((caddr_t
)nmem
+ 8);
3635 return realloc(mem
, size
);
3640 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3642 #ifdef HARD_MALLOC_TESTS
3643 void *mem
= my_malloc(ptr
, nelem
* size
);
3646 memset(mem
, 0, nelem
* size
);
3652 return calloc(nelem
, size
);
3656 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3658 memcached_return_t rc
;
3659 const char *key
= "mine";
3662 /* Make sure be default none exists */
3663 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3665 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3667 /* Test a clean set */
3668 test_compare(MEMCACHED_SUCCESS
,
3669 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3671 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3673 test_memcmp(value
, key
, 4);
3674 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3676 /* Test that we can turn it off */
3677 test_compare(MEMCACHED_SUCCESS
,
3678 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3680 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3682 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3684 /* Now setup for main test */
3685 test_compare(MEMCACHED_SUCCESS
,
3686 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3688 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3690 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3691 test_memcmp(value
, key
, 4);
3693 /* Set to Zero, and then Set to something too large */
3696 memset(long_key
, 0, 255);
3698 test_compare(MEMCACHED_SUCCESS
,
3699 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3701 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3703 test_compare(MEMCACHED_SUCCESS
, rc
);
3705 /* Test a long key for failure */
3706 /* TODO, extend test to determine based on setting, what result should be */
3707 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3708 test_compare(MEMCACHED_SUCCESS
,
3709 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3711 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3712 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3713 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3714 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3716 /* Test for a bad prefix, but with a short key */
3717 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3718 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3720 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3721 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3724 return TEST_SUCCESS
;
3727 static test_return_t
set_namespace(memcached_st
*memc
)
3729 memcached_return_t rc
;
3730 const char *key
= "mine";
3733 // Make sure we default to a null namespace
3734 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3736 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3738 /* Test a clean set */
3739 test_compare(MEMCACHED_SUCCESS
,
3740 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3742 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3744 test_memcmp(value
, key
, 4);
3745 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3747 return TEST_SUCCESS
;
3750 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3752 test_return_if(pre_binary(memc
));
3753 test_return_if(set_namespace(memc
));
3755 return TEST_SUCCESS
;
3758 #ifdef MEMCACHED_ENABLE_DEPRECATED
3759 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3761 void *test_ptr
= NULL
;
3764 memcached_malloc_fn malloc_cb
=
3765 (memcached_malloc_fn
)my_malloc
;
3766 cb_ptr
= *(void **)&malloc_cb
;
3767 memcached_return_t rc
;
3769 test_compare(MEMCACHED_SUCCESS
,
3770 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3771 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3772 test_compare(MEMCACHED_SUCCESS
, rc
);
3773 test_true(test_ptr
== cb_ptr
);
3777 memcached_realloc_fn realloc_cb
=
3778 (memcached_realloc_fn
)my_realloc
;
3779 cb_ptr
= *(void **)&realloc_cb
;
3780 memcached_return_t rc
;
3782 test_compare(MEMCACHED_SUCCESS
,
3783 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3784 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3785 test_compare(MEMCACHED_SUCCESS
, rc
);
3786 test_true(test_ptr
== cb_ptr
);
3790 memcached_free_fn free_cb
=
3791 (memcached_free_fn
)my_free
;
3792 cb_ptr
= *(void **)&free_cb
;
3793 memcached_return_t rc
;
3795 test_compare(MEMCACHED_SUCCESS
,
3796 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3797 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3798 test_compare(MEMCACHED_SUCCESS
, rc
);
3799 test_true(test_ptr
== cb_ptr
);
3802 return TEST_SUCCESS
;
3807 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3809 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3810 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3811 my_realloc
, my_calloc
, NULL
));
3813 test_compare(MEMCACHED_SUCCESS
,
3814 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3815 my_realloc
, my_calloc
, NULL
));
3817 memcached_malloc_fn mem_malloc
;
3818 memcached_free_fn mem_free
;
3819 memcached_realloc_fn mem_realloc
;
3820 memcached_calloc_fn mem_calloc
;
3821 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3822 &mem_realloc
, &mem_calloc
);
3824 test_true(mem_malloc
== my_malloc
);
3825 test_true(mem_realloc
== my_realloc
);
3826 test_true(mem_calloc
== my_calloc
);
3827 test_true(mem_free
== my_free
);
3829 return TEST_SUCCESS
;
3832 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3835 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3836 memcached_hash_t hash
;
3837 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3838 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3841 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3842 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3844 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3846 if (hash
!= MEMCACHED_HASH_CRC
)
3847 return TEST_SKIPPED
;
3849 return TEST_SUCCESS
;
3852 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3855 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3856 memcached_hash_t hash
;
3857 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3858 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3863 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3864 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3866 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3868 if (hash
!= MEMCACHED_HASH_HSIEH
)
3869 return TEST_SKIPPED
;
3872 return TEST_SUCCESS
;
3875 static test_return_t
enable_cas(memcached_st
*memc
)
3877 unsigned int set
= 1;
3879 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3881 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3883 return TEST_SUCCESS
;
3886 return TEST_SKIPPED
;
3889 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3891 memcached_version(memc
);
3893 memcached_server_instance_st instance
=
3894 memcached_server_instance_by_position(memc
, 0);
3896 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3897 or instance
->minor_version
> 2)
3899 return TEST_SUCCESS
;
3902 return TEST_SKIPPED
;
3905 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3909 memcached_servers_reset(memc
);
3910 const char *socket_file
= default_socket();
3912 test_skip(0, stat(socket_file
, &buf
));
3914 test_compare(MEMCACHED_SUCCESS
,
3915 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
3917 return TEST_SUCCESS
;
3920 static test_return_t
pre_nodelay(memcached_st
*memc
)
3922 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3923 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3925 return TEST_SUCCESS
;
3928 static test_return_t
pre_settimer(memcached_st
*memc
)
3930 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3931 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3933 return TEST_SUCCESS
;
3936 static test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3938 const uint64_t timeout
= 100; // Not using, just checking that it sets
3940 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3942 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3944 return TEST_SUCCESS
;
3947 static test_return_t
noreply_test(memcached_st
*memc
)
3949 test_compare(MEMCACHED_SUCCESS
,
3950 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3951 test_compare(MEMCACHED_SUCCESS
,
3952 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3953 test_compare(MEMCACHED_SUCCESS
,
3954 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3955 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3956 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3957 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3959 memcached_return_t ret
;
3960 for (int count
= 0; count
< 5; ++count
)
3962 for (size_t x
= 0; x
< 100; ++x
)
3965 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3966 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3968 size_t len
= (size_t)check_length
;
3973 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3976 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3979 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3982 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3985 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3991 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, ret
));
3995 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3996 ** API and is _ONLY_ done this way to verify that the library works the
3997 ** way it is supposed to do!!!!
4000 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4002 memcached_server_instance_st instance
=
4003 memcached_server_instance_by_position(memc
, x
);
4004 no_msg
+=(int)(instance
->cursor_active
);
4007 test_true(no_msg
== 0);
4008 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4011 ** Now validate that all items was set properly!
4013 for (size_t x
= 0; x
< 100; ++x
)
4017 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4019 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4021 size_t len
= (size_t)check_length
;
4024 char* value
=memcached_get(memc
, key
, strlen(key
),
4025 &length
, &flags
, &ret
);
4026 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
4029 case 0: /* FALLTHROUGH */
4030 case 1: /* FALLTHROUGH */
4032 test_true(strncmp(value
, key
, len
) == 0);
4033 test_true(len
== length
);
4036 test_true(length
== len
* 2);
4039 test_true(length
== len
* 3);
4049 /* Try setting an illegal cas value (should not return an error to
4050 * the caller (because we don't expect a return message from the server)
4052 const char* keys
[]= {"0"};
4053 size_t lengths
[]= {1};
4056 memcached_result_st results_obj
;
4057 memcached_result_st
*results
;
4058 test_compare(MEMCACHED_SUCCESS
,
4059 memcached_mget(memc
, keys
, lengths
, 1));
4061 results
= memcached_result_create(memc
, &results_obj
);
4063 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4065 test_compare(MEMCACHED_SUCCESS
, ret
);
4066 uint64_t cas
= memcached_result_cas(results
);
4067 memcached_result_free(&results_obj
);
4069 test_compare(MEMCACHED_SUCCESS
,
4070 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4073 * The item will have a new cas value, so try to set it again with the old
4074 * value. This should fail!
4076 test_compare(MEMCACHED_SUCCESS
,
4077 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4078 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4079 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4080 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4083 return TEST_SUCCESS
;
4086 static test_return_t
analyzer_test(memcached_st
*memc
)
4088 memcached_return_t rc
;
4089 memcached_analysis_st
*report
;
4091 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4092 test_compare(MEMCACHED_SUCCESS
, rc
);
4093 test_true(memc_stat
);
4095 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4096 test_compare(MEMCACHED_SUCCESS
, rc
);
4100 memcached_stat_free(NULL
, memc_stat
);
4102 return TEST_SUCCESS
;
4105 /* Count the objects */
4107 static test_return_t
dump_test(memcached_st
*memc
)
4109 /* No support for Binary protocol yet */
4110 test_skip(false, memc
->flags
.binary_protocol
);
4112 test_compare(TEST_SUCCESS
, set_test3(memc
));
4114 // confirm_key_count() call dump
4115 size_t counter
= confirm_key_count(memc
);
4117 /* We may have more then 32 if our previous flush has not completed */
4118 test_true(counter
>= 32);
4120 return TEST_SUCCESS
;
4123 static test_return_t
util_version_test(memcached_st
*memc
)
4125 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
4126 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
4128 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4130 // We expect failure
4133 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4134 fprintf(stderr
, "\nDumping Server Information\n\n");
4135 memcached_server_fn callbacks
[1];
4137 callbacks
[0]= dump_server_information
;
4138 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4139 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4141 test_true(if_successful
== false);
4143 memcached_server_instance_st instance
=
4144 memcached_server_instance_by_position(memc
, 0);
4146 memcached_version(memc
);
4148 // We only use one binary when we test, so this should be just fine.
4149 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4150 test_true(if_successful
== true);
4152 if (instance
->micro_version
> 0)
4154 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4156 else if (instance
->minor_version
> 0)
4158 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4160 else if (instance
->major_version
> 0)
4162 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4165 test_true(if_successful
== true);
4167 if (instance
->micro_version
> 0)
4169 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4171 else if (instance
->minor_version
> 0)
4173 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4175 else if (instance
->major_version
> 0)
4177 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4180 test_true(if_successful
== false);
4182 return TEST_SUCCESS
;
4185 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4187 memcached_return_t rc
;
4188 memcached_server_instance_st instance
=
4189 memcached_server_instance_by_position(memc
, 0);
4191 // Test both the version that returns a code, and the one that does not.
4192 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4193 memcached_server_port(instance
) -1, NULL
) == -1);
4195 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4196 memcached_server_port(instance
) -1, &rc
) == -1);
4197 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4199 return TEST_SUCCESS
;
4203 static test_return_t
getpid_test(memcached_st
*memc
)
4205 memcached_return_t rc
;
4206 memcached_server_instance_st instance
=
4207 memcached_server_instance_by_position(memc
, 0);
4209 // Test both the version that returns a code, and the one that does not.
4210 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4211 memcached_server_port(instance
), NULL
) > -1);
4213 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4214 memcached_server_port(instance
), &rc
) > -1);
4215 test_compare(MEMCACHED_SUCCESS
, rc
);
4217 return TEST_SUCCESS
;
4220 static test_return_t
ping_test(memcached_st
*memc
)
4222 memcached_return_t rc
;
4223 memcached_server_instance_st instance
=
4224 memcached_server_instance_by_position(memc
, 0);
4226 // Test both the version that returns a code, and the one that does not.
4227 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4228 memcached_server_port(instance
), NULL
));
4230 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4231 memcached_server_port(instance
), &rc
));
4233 test_compare(MEMCACHED_SUCCESS
, rc
);
4235 return TEST_SUCCESS
;
4240 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4244 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4245 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4246 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4247 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4248 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4249 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4250 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4251 #ifdef HAVE_HSIEH_HASH
4252 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4254 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4255 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4256 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4258 return TEST_SUCCESS
;
4262 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4264 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4266 test_compare(MEMCACHED_SUCCESS
,
4267 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4268 (uint64_t)MEMCACHED_HASH_HSIEH
));
4270 return TEST_SUCCESS
;
4273 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4275 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4277 test_compare(MEMCACHED_SUCCESS
,
4278 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
4280 return TEST_SUCCESS
;
4283 static test_return_t
one_at_a_time_run (memcached_st
*)
4288 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4290 test_compare(one_at_a_time_values
[x
],
4291 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
4294 return TEST_SUCCESS
;
4297 static test_return_t
md5_run (memcached_st
*)
4302 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4304 test_compare(md5_values
[x
],
4305 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
4308 return TEST_SUCCESS
;
4311 static test_return_t
crc_run (memcached_st
*)
4316 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4318 test_compare(crc_values
[x
],
4319 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
4322 return TEST_SUCCESS
;
4325 static test_return_t
fnv1_64_run (memcached_st
*)
4327 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
4332 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4334 test_compare(fnv1_64_values
[x
],
4335 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
4338 return TEST_SUCCESS
;
4341 static test_return_t
fnv1a_64_run (memcached_st
*)
4343 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
4348 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4350 test_compare(fnv1a_64_values
[x
],
4351 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
4354 return TEST_SUCCESS
;
4357 static test_return_t
fnv1_32_run (memcached_st
*)
4362 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4364 test_compare(fnv1_32_values
[x
],
4365 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
4368 return TEST_SUCCESS
;
4371 static test_return_t
fnv1a_32_run (memcached_st
*)
4376 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4378 test_compare(fnv1a_32_values
[x
],
4379 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
4382 return TEST_SUCCESS
;
4385 static test_return_t
hsieh_run (memcached_st
*)
4387 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4392 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4394 test_compare(hsieh_values
[x
],
4395 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
4398 return TEST_SUCCESS
;
4401 static test_return_t
murmur_run (memcached_st
*)
4403 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4405 #ifdef WORDS_BIGENDIAN
4406 (void)murmur_values
;
4407 return TEST_SKIPPED
;
4412 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4414 test_compare(murmur_values
[x
],
4415 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
4418 return TEST_SUCCESS
;
4422 static test_return_t
jenkins_run (memcached_st
*)
4427 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4429 test_compare(jenkins_values
[x
],
4430 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
4433 return TEST_SUCCESS
;
4436 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
4438 return libhashkit_md5(string
, string_length
);
4441 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
4443 return libhashkit_crc32(string
, string_length
);
4446 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4452 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
4454 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};
4455 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};
4457 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4459 hashkit_clone(&new_kit
, kit
);
4460 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4462 memcached_set_hashkit(memc
, &new_kit
);
4465 Verify Setting the hash.
4467 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4471 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4472 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4477 Now check memcached_st.
4479 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4483 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4484 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4487 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4489 memcached_set_hashkit(memc
, &new_kit
);
4492 Verify Setting the hash.
4494 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4498 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4499 test_true(crc_values
[x
] == hash_val
);
4502 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4506 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4507 test_compare(crc_hosts
[x
], hash_val
);
4510 memcached_free(memc
);
4512 return TEST_SUCCESS
;
4516 Test case adapted from John Gorman <johngorman2@gmail.com>
4518 We are testing the error condition when we connect to a server via memcached_get()
4519 but find that the server is not available.
4521 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4523 const char *key
= "MemcachedLives";
4526 memcached_return rc
;
4529 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4531 // See if memcached is reachable.
4532 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4536 test_true(memcached_failed(rc
));
4538 memcached_free(tl_memc_h
);
4540 return TEST_SUCCESS
;
4544 We connect to a server which exists, but search for a key that does not exist.
4546 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4548 const char *key
= "MemcachedKeyNotEXIST";
4551 memcached_return rc
;
4553 // See if memcached is reachable.
4554 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4558 test_compare(MEMCACHED_NOTFOUND
, rc
);
4560 return TEST_SUCCESS
;
4564 Test case adapted from John Gorman <johngorman2@gmail.com>
4566 We are testing the error condition when we connect to a server via memcached_get_by_key()
4567 but find that the server is not available.
4569 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4572 memcached_st
*tl_memc_h
;
4573 memcached_server_st
*servers
;
4575 const char *key
= "MemcachedLives";
4578 memcached_return rc
;
4582 tl_memc_h
= memcached_create(NULL
);
4583 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4584 memcached_server_push(tl_memc_h
, servers
);
4585 memcached_server_list_free(servers
);
4587 // See if memcached is reachable.
4588 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4592 test_true(memcached_failed(rc
));
4594 memcached_free(tl_memc_h
);
4596 return TEST_SUCCESS
;
4600 We connect to a server which exists, but search for a key that does not exist.
4602 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4604 const char *key
= "MemcachedKeyNotEXIST";
4607 memcached_return rc
;
4610 // See if memcached is reachable.
4611 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4615 test_compare(MEMCACHED_NOTFOUND
, rc
);
4617 return TEST_SUCCESS
;
4620 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4622 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4624 const char *key
= "regression_bug_434484";
4625 size_t keylen
= strlen(key
);
4627 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4628 test_compare(MEMCACHED_NOTSTORED
, ret
);
4630 size_t size
= 2048 * 1024;
4631 char *data
= (char*)calloc(1, size
);
4633 test_compare(MEMCACHED_E2BIG
,
4634 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4637 return TEST_SUCCESS
;
4640 static test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4642 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4644 memcached_return_t rc
;
4646 memcached_execute_fn callbacks
[]= { &callback_counter
};
4649 * I only want to hit only _one_ server so I know the number of requests I'm
4650 * sending in the pipleine to the server. Let's try to do a multiget of
4651 * 1024 (that should satisfy most users don't you think?). Future versions
4652 * will include a mget_execute function call if you need a higher number.
4654 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4656 const size_t max_keys
= 1024;
4657 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4658 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4660 for (size_t x
= 0; x
< max_keys
; ++x
)
4664 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4670 * Run two times.. the first time we should have 100% cache miss,
4671 * and the second time we should have 100% cache hits
4673 for (size_t y
= 0; y
< 2; y
++)
4675 test_compare(MEMCACHED_SUCCESS
,
4676 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4678 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4679 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4683 /* The first iteration should give me a 100% cache miss. verify that*/
4684 char blob
[1024]= { 0 };
4686 test_false(counter
);
4688 for (size_t x
= 0; x
< max_keys
; ++x
)
4690 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4691 blob
, sizeof(blob
), 0, 0);
4692 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4697 /* Verify that we received all of the key/value pairs */
4698 test_compare(counter
, max_keys
);
4702 /* Release allocated resources */
4703 for (size_t x
= 0; x
< max_keys
; ++x
)
4710 memcached_free(memc
);
4712 return TEST_SUCCESS
;
4715 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4717 memcached_return_t rc
;
4718 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4719 test_compare(MEMCACHED_SUCCESS
, rc
);
4721 return regression_bug_434843(memc
);
4724 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4726 memcached_return_t rc
;
4727 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4728 test_compare(MEMCACHED_SUCCESS
, rc
);
4730 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4731 test_compare(MEMCACHED_SUCCESS
, rc
);
4732 test_true(bytes_str
);
4733 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4735 test_compare(MEMCACHED_SUCCESS
, rc
);
4736 test_true(bytes_read_str
);
4738 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4739 "bytes_written", &rc
);
4740 test_compare(MEMCACHED_SUCCESS
, rc
);
4741 test_true(bytes_written_str
);
4743 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4744 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4745 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4747 test_true(bytes
!= bytes_read
);
4748 test_true(bytes
!= bytes_written
);
4750 /* Release allocated resources */
4752 free(bytes_read_str
);
4753 free(bytes_written_str
);
4754 memcached_stat_free(NULL
, memc_stat
);
4756 return TEST_SUCCESS
;
4760 * The test case isn't obvious so I should probably document why
4761 * it works the way it does. Bug 442914 was caused by a bug
4762 * in the logic in memcached_purge (it did not handle the case
4763 * where the number of bytes sent was equal to the watermark).
4764 * In this test case, create messages so that we hit that case
4765 * and then disable noreply mode and issue a new command to
4766 * verify that it isn't stuck. If we change the format for the
4767 * delete command or the watermarks, we need to update this
4770 static test_return_t
regression_bug_442914(memcached_st
*memc
)
4772 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4773 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4775 uint32_t number_of_hosts
= memcached_server_count(memc
);
4776 memc
->number_of_hosts
= 1;
4781 for (uint32_t x
= 0; x
< 250; ++x
)
4783 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4784 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4785 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4788 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
4791 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4792 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4794 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4795 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
4797 memc
->number_of_hosts
= number_of_hosts
;
4799 return TEST_SUCCESS
;
4802 static test_return_t
regression_bug_447342(memcached_st
*memc
)
4804 memcached_server_instance_st instance_one
;
4805 memcached_server_instance_st instance_two
;
4807 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4808 return TEST_SKIPPED
;
4810 test_compare(MEMCACHED_SUCCESS
,
4811 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4813 const unsigned int max_keys
= 100;
4814 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4815 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4817 for (unsigned int x
= 0; x
< max_keys
; ++x
)
4821 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4824 test_compare(MEMCACHED_SUCCESS
,
4825 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
4829 ** We are using the quiet commands to store the replicas, so we need
4830 ** to ensure that all of them are processed before we can continue.
4831 ** In the test we go directly from storing the object to trying to
4832 ** receive the object from all of the different servers, so we
4833 ** could end up in a race condition (the memcached server hasn't yet
4834 ** processed the quiet command from the replication set when it process
4835 ** the request from the other client (created by the clone)). As a
4836 ** workaround for that we call memcached_quit to send the quit command
4837 ** to the server and wait for the response ;-) If you use the test code
4838 ** as an example for your own code, please note that you shouldn't need
4841 memcached_quit(memc
);
4843 /* Verify that all messages are stored, and we didn't stuff too much
4846 test_compare(MEMCACHED_SUCCESS
,
4847 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4849 unsigned int counter
= 0;
4850 memcached_execute_fn callbacks
[]= { &callback_counter
};
4851 test_compare(MEMCACHED_SUCCESS
,
4852 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4854 /* Verify that we received all of the key/value pairs */
4855 test_compare(counter
, max_keys
);
4857 memcached_quit(memc
);
4859 * Don't do the following in your code. I am abusing the internal details
4860 * within the library, and this is not a supported interface.
4861 * This is to verify correct behavior in the library. Fake that two servers
4864 instance_one
= memcached_server_instance_by_position(memc
, 0);
4865 instance_two
= memcached_server_instance_by_position(memc
, 2);
4866 in_port_t port0
= instance_one
->port
;
4867 in_port_t port2
= instance_two
->port
;
4869 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4870 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4872 test_compare(MEMCACHED_SUCCESS
,
4873 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4876 test_compare(MEMCACHED_SUCCESS
,
4877 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4878 test_compare(counter
, (unsigned int)max_keys
);
4880 /* restore the memc handle */
4881 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4882 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4884 memcached_quit(memc
);
4886 /* Remove half of the objects */
4887 for (size_t x
= 0; x
< max_keys
; ++x
)
4891 test_compare(MEMCACHED_SUCCESS
,
4892 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
4896 memcached_quit(memc
);
4897 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4898 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4900 /* now retry the command, this time we should have cache misses */
4901 test_compare(MEMCACHED_SUCCESS
,
4902 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4905 test_compare(MEMCACHED_SUCCESS
,
4906 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4907 test_compare(counter
, (unsigned int)(max_keys
>> 1));
4909 /* Release allocated resources */
4910 for (size_t x
= 0; x
< max_keys
; ++x
)
4917 /* restore the memc handle */
4918 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4919 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4921 return TEST_SUCCESS
;
4924 static test_return_t
regression_bug_463297(memcached_st
*memc
)
4926 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4927 test_true(memc_clone
);
4928 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4930 memcached_server_instance_st instance
=
4931 memcached_server_instance_by_position(memc_clone
, 0);
4933 if (instance
->major_version
> 1 ||
4934 (instance
->major_version
== 1 &&
4935 instance
->minor_version
> 2))
4937 /* Binary protocol doesn't support deferred delete */
4938 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4939 test_true(bin_clone
);
4940 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4941 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4942 memcached_free(bin_clone
);
4944 memcached_quit(memc_clone
);
4946 /* If we know the server version, deferred delete should fail
4947 * with invalid arguments */
4948 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4950 /* If we don't know the server version, we should get a protocol error */
4951 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4953 /* but there is a bug in some of the memcached servers (1.4) that treats
4954 * the counter as noreply so it doesn't send the proper error message
4956 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4958 /* And buffered mode should be disabled and we should get protocol error */
4959 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4960 rc
= memcached_delete(memc
, "foo", 3, 1);
4961 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4963 /* Same goes for noreply... */
4964 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4965 rc
= memcached_delete(memc
, "foo", 3, 1);
4966 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4968 /* but a normal request should go through (and be buffered) */
4969 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4970 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4972 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4973 /* unbuffered noreply should be success */
4974 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4975 /* unbuffered with reply should be not found... */
4976 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4977 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4980 memcached_free(memc_clone
);
4981 return TEST_SUCCESS
;
4985 /* Test memcached_server_get_last_disconnect
4986 * For a working server set, shall be NULL
4987 * For a set of non existing server, shall not be NULL
4989 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4991 memcached_return_t rc
;
4992 memcached_server_instance_st disconnected_server
;
4994 /* With the working set of server */
4995 const char *key
= "marmotte";
4996 const char *value
= "milka";
4998 memcached_reset_last_disconnected_server(memc
);
4999 test_false(memc
->last_disconnected_server
);
5000 rc
= memcached_set(memc
, key
, strlen(key
),
5001 value
, strlen(value
),
5002 (time_t)0, (uint32_t)0);
5003 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5005 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5006 test_false(disconnected_server
);
5008 /* With a non existing server */
5010 memcached_server_st
*servers
;
5012 const char *server_list
= "localhost:9";
5014 servers
= memcached_servers_parse(server_list
);
5016 mine
= memcached_create(NULL
);
5017 rc
= memcached_server_push(mine
, servers
);
5018 test_compare(MEMCACHED_SUCCESS
, rc
);
5019 memcached_server_list_free(servers
);
5022 rc
= memcached_set(mine
, key
, strlen(key
),
5023 value
, strlen(value
),
5024 (time_t)0, (uint32_t)0);
5025 test_true(memcached_failed(rc
));
5027 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5028 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5029 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5030 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5032 memcached_quit(mine
);
5033 memcached_free(mine
);
5035 return TEST_SUCCESS
;
5038 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5040 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5041 char buffer
[BUFSIZ
];
5043 test_compare(MEMCACHED_SUCCESS
,
5044 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5046 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5049 // We will just use the error strings as our keys
5050 uint32_t counter
= 100;
5053 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5055 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5056 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5057 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
5059 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5060 test_true(disconnected_server
);
5061 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5062 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5066 memcached_reset_last_disconnected_server(memc
);
5071 memcached_free(memc
);
5073 return TEST_SUCCESS
;
5076 static test_return_t
test_verbosity(memcached_st
*memc
)
5078 memcached_verbosity(memc
, 3);
5080 return TEST_SUCCESS
;
5084 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5085 const char *key
, size_t key_length
,
5086 const char *value
, size_t value_length
,
5096 return MEMCACHED_SUCCESS
;
5099 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5101 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5102 test_compare(MEMCACHED_SUCCESS
, rc
);
5104 test_compare(MEMCACHED_SUCCESS
,
5105 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
5107 test_compare(MEMCACHED_SUCCESS
,
5108 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
5110 test_compare(MEMCACHED_SUCCESS
,
5111 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
5113 return TEST_SUCCESS
;
5117 * This test ensures that the failure counter isn't incremented during
5118 * normal termination of the memcached instance.
5120 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5122 memcached_return_t rc
;
5123 memcached_server_instance_st instance
;
5125 /* Set value to force connection to the server */
5126 const char *key
= "marmotte";
5127 const char *value
= "milka";
5130 * Please note that I'm abusing the internal structures in libmemcached
5131 * in a non-portable way and you shouldn't be doing this. I'm only
5132 * doing this in order to verify that the library works the way it should
5134 uint32_t number_of_hosts
= memcached_server_count(memc
);
5135 memc
->number_of_hosts
= 1;
5137 /* Ensure that we are connected to the server by setting a value */
5138 rc
= memcached_set(memc
, key
, strlen(key
),
5139 value
, strlen(value
),
5140 (time_t)0, (uint32_t)0);
5141 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5144 instance
= memcached_server_instance_by_position(memc
, 0);
5145 /* The test is to see that the memcached_quit doesn't increase the
5146 * the server failure conter, so let's ensure that it is zero
5147 * before sending quit
5149 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5151 memcached_quit(memc
);
5153 /* Verify that it memcached_quit didn't increment the failure counter
5154 * Please note that this isn't bullet proof, because an error could
5157 test_zero(instance
->server_failure_counter
);
5159 /* restore the instance */
5160 memc
->number_of_hosts
= number_of_hosts
;
5162 return TEST_SUCCESS
;
5166 * This tests ensures expected disconnections (for some behavior changes
5167 * for instance) do not wrongly increase failure counter
5169 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5171 /* Set value to force connection to the server */
5172 const char *key
= "marmotte";
5173 const char *value
= "milka";
5175 test_compare_hint(MEMCACHED_SUCCESS
,
5176 memcached_set(memc
, key
, strlen(key
),
5177 value
, strlen(value
),
5178 (time_t)0, (uint32_t)0),
5179 memcached_last_error_message(memc
));
5182 /* put failure limit to 1 */
5183 test_compare(MEMCACHED_SUCCESS
,
5184 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
5186 /* Put a retry timeout to effectively activate failure_limit effect */
5187 test_compare(MEMCACHED_SUCCESS
,
5188 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
5190 /* change behavior that triggers memcached_quit()*/
5191 test_compare(MEMCACHED_SUCCESS
,
5192 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
5195 /* Check if we still are connected */
5197 size_t string_length
;
5198 memcached_return rc
;
5199 char *string
= memcached_get(memc
, key
, strlen(key
),
5200 &string_length
, &flags
, &rc
);
5202 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5206 return TEST_SUCCESS
;
5211 * Test that ensures mget_execute does not end into recursive calls that finally fails
5213 static test_return_t
regression_bug_490486(memcached_st
*original_memc
)
5217 return TEST_SKIPPED
; // My MAC can't handle this test
5220 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
5223 * I only want to hit _one_ server so I know the number of requests I'm
5224 * sending in the pipeline.
5226 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
5229 size_t max_keys
= 20480;
5231 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5232 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5234 /* First add all of the items.. */
5235 char blob
[1024]= { 0 };
5236 for (size_t x
= 0; x
< max_keys
; ++x
)
5239 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5242 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5243 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5248 /* Try to get all of them with a large multiget */
5250 memcached_execute_function callbacks
[]= { &callback_counter
};
5251 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5252 (size_t)max_keys
, callbacks
, &counter
, 1);
5253 test_compare(MEMCACHED_SUCCESS
, rc
);
5255 char* the_value
= NULL
;
5256 char the_key
[MEMCACHED_MAX_KEY
];
5257 size_t the_key_length
;
5258 size_t the_value_length
;
5262 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5264 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5270 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5273 test_compare(MEMCACHED_END
, rc
);
5275 /* Verify that we got all of the items */
5276 test_compare(counter
, max_keys
);
5279 /* Release all allocated resources */
5280 for (size_t x
= 0; x
< max_keys
; ++x
)
5287 memcached_free(memc
);
5289 return TEST_SUCCESS
;
5292 static test_return_t
regression_bug_583031(memcached_st
*)
5294 memcached_st
*memc
= memcached_create(NULL
);
5296 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5298 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5299 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5300 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5301 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5302 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5303 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5305 memcached_return_t rc
;
5309 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5313 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5315 memcached_free(memc
);
5317 return TEST_SUCCESS
;
5320 static test_return_t
regression_bug_581030(memcached_st
*)
5323 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5324 test_false(local_stat
);
5326 memcached_stat_free(NULL
, NULL
);
5329 return TEST_SUCCESS
;
5332 #define regression_bug_655423_COUNT 6000
5333 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5335 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5336 memc
= NULL
; // Just to make sure it is not used
5341 return TEST_SKIPPED
;
5344 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5345 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5346 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5347 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5349 memset(payload
, int('x'), sizeof(payload
));
5351 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5353 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5354 snprintf(key
, sizeof(key
), "%u", x
);
5356 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5359 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5361 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5362 snprintf(key
, sizeof(key
), "%u", x
);
5364 size_t value_length
;
5365 memcached_return_t rc
;
5366 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5368 if (rc
== MEMCACHED_NOTFOUND
)
5371 test_zero(value_length
);
5375 test_compare(MEMCACHED_SUCCESS
, rc
);
5377 test_compare(100LLU, value_length
);
5381 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5382 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5383 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5385 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5386 snprintf(key
, sizeof(key
), "%u", x
);
5388 keys
[x
]= strdup(key
);
5390 key_length
[x
]= strlen(key
);
5391 test_true(key_length
[x
]);
5394 test_compare(MEMCACHED_SUCCESS
,
5395 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5398 memcached_result_st
*result
= NULL
;
5399 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5401 test_compare(size_t(100), memcached_result_length(result
));
5405 test_true(count
> 100); // If we don't get back atleast this, something is up
5407 /* Release all allocated resources */
5408 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5416 memcached_free(clone
);
5418 return TEST_SUCCESS
;
5422 * Test that ensures that buffered set to not trigger problems during io_flush
5424 #define regression_bug_490520_COUNT 200480
5425 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5427 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5428 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5429 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5430 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5431 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5433 memc
->number_of_hosts
= 1;
5435 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5436 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5438 /* First add all of the items.. */
5439 char blob
[3333] = {0};
5440 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5443 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5447 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5448 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5451 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5458 return TEST_SUCCESS
;
5462 static test_return_t
regression_bug_854604(memcached_st
*)
5466 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
5468 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
5470 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
5471 test_compare(buffer
[0], 0);
5473 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
5474 test_true(strlen(buffer
));
5476 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
5477 test_true(strlen(buffer
));
5479 return TEST_SUCCESS
;
5482 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5484 fprintf(stderr
, "Iteration #%u: ", it
);
5486 if (error
== MEMCACHED_ERRNO
)
5488 fprintf(stderr
, "system error %d from %s: %s\n",
5489 errno
, what
, strerror(errno
));
5493 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5494 memcached_strerror(mc
, error
));
5498 #define TEST_CONSTANT_CREATION 200
5500 static test_return_t
regression_bug_(memcached_st
*memc
)
5502 const char *remote_server
;
5505 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5507 return TEST_SKIPPED
;
5510 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5512 memcached_st
* mc
= memcached_create(NULL
);
5513 memcached_return rc
;
5515 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5516 if (rc
!= MEMCACHED_SUCCESS
)
5518 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5521 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5522 if (rc
!= MEMCACHED_SUCCESS
)
5524 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5527 rc
= memcached_server_add(mc
, remote_server
, 0);
5528 if (rc
!= MEMCACHED_SUCCESS
)
5530 memcached_die(mc
, rc
, "memcached_server_add", x
);
5533 const char *set_key
= "akey";
5534 const size_t set_key_len
= strlen(set_key
);
5535 const char *set_value
= "a value";
5536 const size_t set_value_len
= strlen(set_value
);
5538 if (rc
== MEMCACHED_SUCCESS
)
5542 size_t get_value_len
;
5544 uint32_t get_value_flags
;
5546 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5547 &get_value_flags
, &rc
);
5548 if (rc
!= MEMCACHED_SUCCESS
)
5550 memcached_die(mc
, rc
, "memcached_get", x
);
5556 (get_value_len
!= set_value_len
5557 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5559 fprintf(stderr
, "Values don't match?\n");
5560 rc
= MEMCACHED_FAILURE
;
5566 rc
= memcached_set(mc
,
5567 set_key
, set_key_len
,
5568 set_value
, set_value_len
,
5572 if (rc
!= MEMCACHED_SUCCESS
)
5574 memcached_die(mc
, rc
, "memcached_set", x
);
5581 if (rc
!= MEMCACHED_SUCCESS
)
5587 return TEST_SUCCESS
;
5590 /* Clean the server before beginning testing */
5592 {"util_version", true, (test_callback_fn
*)util_version_test
},
5593 {"flush", false, (test_callback_fn
*)flush_test
},
5594 {"init", false, (test_callback_fn
*)init_test
},
5595 {"allocation", false, (test_callback_fn
*)allocation_test
},
5596 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5597 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5598 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5599 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5600 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5601 {"clone_test", false, (test_callback_fn
*)clone_test
},
5602 {"connection_test", false, (test_callback_fn
*)connection_test
},
5603 {"callback_test", false, (test_callback_fn
*)callback_test
},
5604 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5605 {"set", false, (test_callback_fn
*)set_test
},
5606 {"set2", false, (test_callback_fn
*)set_test2
},
5607 {"set3", false, (test_callback_fn
*)set_test3
},
5608 {"dump", true, (test_callback_fn
*)dump_test
},
5609 {"add", true, (test_callback_fn
*)add_test
},
5610 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5611 {"replace", true, (test_callback_fn
*)replace_test
},
5612 {"delete", true, (test_callback_fn
*)delete_test
},
5613 {"get", true, (test_callback_fn
*)get_test
},
5614 {"get2", false, (test_callback_fn
*)get_test2
},
5615 {"get3", false, (test_callback_fn
*)get_test3
},
5616 {"get4", false, (test_callback_fn
*)get_test4
},
5617 {"partial mget", false, (test_callback_fn
*)get_test5
},
5618 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5619 {"increment", false, (test_callback_fn
*)increment_test
},
5620 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5621 {"decrement", false, (test_callback_fn
*)decrement_test
},
5622 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5623 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5624 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5625 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5626 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5627 {"binary_increment_with_prefix", 1, (test_callback_fn
*)binary_increment_with_prefix_test
},
5628 {"quit", false, (test_callback_fn
*)quit_test
},
5629 {"mget", true, (test_callback_fn
*)mget_test
},
5630 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5631 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5632 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5633 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5634 {"mget_end", false, (test_callback_fn
*)mget_end
},
5635 {"get_stats", false, (test_callback_fn
*)get_stats
},
5636 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5637 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5638 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5639 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
5640 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5641 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5642 {"read_through", true, (test_callback_fn
*)read_through
},
5643 {"delete_through", true, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER
},
5644 {"noreply", true, (test_callback_fn
*)noreply_test
},
5645 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5646 {"memcached_pool_st", true, (test_callback_fn
*)connection_pool_test
},
5647 {"memcached_pool_st #2", true, (test_callback_fn
*)connection_pool2_test
},
5649 {"memcached_pool_st #3", true, (test_callback_fn
*)connection_pool3_test
},
5651 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
5652 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
5653 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
5654 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
5655 {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_NOTFOUND
},
5656 {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_SUCCESS
},
5657 {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_by_key_NOTFOUND
},
5658 {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_by_key_SUCCESS
},
5659 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5660 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5664 test_st touch_tests
[] ={
5665 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5666 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5670 test_st behavior_tests
[] ={
5671 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5672 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5673 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5674 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5675 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5676 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5677 {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test
},
5678 {"MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY", false, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY
},
5682 test_st libmemcachedutil_tests
[] ={
5683 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5684 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5685 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5689 test_st basic_tests
[] ={
5690 {"init", true, (test_callback_fn
*)basic_init_test
},
5691 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5692 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5693 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5694 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5695 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5696 {"memcached_return_t", false, (test_callback_fn
*)memcached_return_t_TEST
},
5700 test_st regression_binary_vs_block
[] ={
5701 {"block add", true, (test_callback_fn
*)block_add_regression
},
5702 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
5706 test_st async_tests
[] ={
5707 {"add", true, (test_callback_fn
*)add_wrapper
},
5711 test_st memcached_server_get_last_disconnect_tests
[] ={
5712 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
5713 {0, 0, (test_callback_fn
*)0}
5717 test_st result_tests
[] ={
5718 {"result static", false, (test_callback_fn
*)result_static
},
5719 {"result alloc", false, (test_callback_fn
*)result_alloc
},
5720 {0, 0, (test_callback_fn
*)0}
5723 test_st version_1_2_3
[] ={
5724 {"append", false, (test_callback_fn
*)append_test
},
5725 {"prepend", false, (test_callback_fn
*)prepend_test
},
5726 {"cas", false, (test_callback_fn
*)cas_test
},
5727 {"cas2", false, (test_callback_fn
*)cas2_test
},
5728 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
5729 {0, 0, (test_callback_fn
*)0}
5732 test_st haldenbrand_tests
[] ={
5733 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
5734 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
5735 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
5736 {0, 0, (test_callback_fn
*)0}
5739 test_st user_tests
[] ={
5740 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
5741 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
5742 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
5743 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
5744 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
5745 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
5746 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
5747 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
5748 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
5749 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
5750 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
5751 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
5752 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
5753 #if !defined(__sun) && !defined(__OpenBSD__)
5755 ** It seems to be something weird with the character sets..
5756 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5757 ** guess I need to find out how this is supposed to work.. Perhaps I need
5758 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5759 ** so just disable the code for now...).
5761 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
5763 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
5764 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
5765 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
5766 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
5767 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
5768 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
5769 {0, 0, (test_callback_fn
*)0}
5772 test_st replication_tests
[]= {
5773 {"set", true, (test_callback_fn
*)replication_set_test
},
5774 {"get", false, (test_callback_fn
*)replication_get_test
},
5775 {"mget", false, (test_callback_fn
*)replication_mget_test
},
5776 {"delete", true, (test_callback_fn
*)replication_delete_test
},
5777 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
5778 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
5779 {0, 0, (test_callback_fn
*)0}
5783 * The following test suite is used to verify that we don't introduce
5784 * regression bugs. If you want more information about the bug / test,
5785 * you should look in the bug report at
5786 * http://bugs.launchpad.net/libmemcached
5788 test_st regression_tests
[]= {
5789 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
5790 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
5791 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
5792 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
5793 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
5794 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
5795 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
5796 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
5797 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
5798 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
5799 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
5800 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
5801 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
5802 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
5803 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
5804 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
5805 {"lp:854604", true, (test_callback_fn
*)regression_bug_854604
},
5806 {0, false, (test_callback_fn
*)0}
5809 test_st ketama_compatibility
[]= {
5810 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
5811 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
5812 {0, 0, (test_callback_fn
*)0}
5815 test_st generate_tests
[] ={
5816 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5817 {"generate_data", true, (test_callback_fn
*)generate_data
},
5818 {"get_read", false, (test_callback_fn
*)get_read
},
5819 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
5820 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5821 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
5822 {"generate_data", true, (test_callback_fn
*)generate_data
},
5823 {"mget_read", false, (test_callback_fn
*)mget_read
},
5824 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
5825 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
5826 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
5827 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
5828 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5829 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
5830 {"generate_data", true, (test_callback_fn
*)generate_data
},
5831 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5832 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5833 {0, 0, (test_callback_fn
*)0}
5836 test_st consistent_tests
[] ={
5837 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5838 {"generate_data", true, (test_callback_fn
*)generate_data
},
5839 {"get_read", 0, (test_callback_fn
*)get_read_count
},
5840 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5841 {0, 0, (test_callback_fn
*)0}
5844 test_st consistent_weighted_tests
[] ={
5845 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5846 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
5847 {"get_read", false, (test_callback_fn
*)get_read_count
},
5848 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5849 {0, 0, (test_callback_fn
*)0}
5852 test_st hsieh_availability
[] ={
5853 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
5854 {0, 0, (test_callback_fn
*)0}
5857 test_st murmur_availability
[] ={
5858 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
5859 {0, 0, (test_callback_fn
*)0}
5863 test_st hash_sanity
[] ={
5864 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
5865 {0, 0, (test_callback_fn
*)0}
5869 test_st ketama_auto_eject_hosts
[] ={
5870 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
5871 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
5872 {0, 0, (test_callback_fn
*)0}
5875 test_st hash_tests
[] ={
5876 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
5877 {"md5", false, (test_callback_fn
*)md5_run
},
5878 {"crc", false, (test_callback_fn
*)crc_run
},
5879 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
5880 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
5881 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
5882 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
5883 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
5884 {"murmur", false, (test_callback_fn
*)murmur_run
},
5885 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
5886 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
5887 {0, 0, (test_callback_fn
*)0}
5890 test_st error_conditions
[] ={
5891 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
5892 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
5893 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
5894 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5895 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5896 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
5897 {0, 0, (test_callback_fn
*)0}
5900 test_st parser_tests
[] ={
5901 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
5902 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
5903 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
5904 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
5905 {"hash", false, (test_callback_fn
*)parser_hash_test
},
5906 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
5907 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
5908 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
5909 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
5910 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
5911 {"server", false, (test_callback_fn
*)server_test
},
5912 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
5913 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
5914 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
5915 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
5916 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
5917 {0, 0, (test_callback_fn
*)0}
5920 test_st virtual_bucket_tests
[] ={
5921 {"basic", false, (test_callback_fn
*)virtual_back_map
},
5922 {0, 0, (test_callback_fn
*)0}
5925 test_st memcached_server_add_tests
[] ={
5926 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
5927 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
5928 {0, 0, (test_callback_fn
*)0}
5931 test_st namespace_tests
[] ={
5932 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
5933 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
5934 {0, 0, (test_callback_fn
*)0}
5937 collection_st collection
[] ={
5939 {"hash_sanity", 0, 0, hash_sanity
},
5941 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
5942 {"basic", 0, 0, basic_tests
},
5943 {"hsieh_availability", 0, 0, hsieh_availability
},
5944 {"murmur_availability", 0, 0, murmur_availability
},
5945 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
5946 {"block", 0, 0, tests
},
5947 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
5948 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
5949 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5950 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
5951 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
5952 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
5953 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
5954 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
5955 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
5956 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
5957 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
5958 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
5959 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
5960 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
5961 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
5962 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5963 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
5964 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
5965 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
5966 #ifdef MEMCACHED_ENABLE_DEPRECATED
5967 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
5969 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
5970 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
5971 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
5972 {"specific namespace", 0, 0, namespace_tests
},
5973 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
5974 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
5975 {"result", 0, 0, result_tests
},
5976 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
5977 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
5978 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
5979 {"user written tests", 0, 0, user_tests
},
5980 {"generate", 0, 0, generate_tests
},
5981 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
5982 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
5983 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
5984 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
5985 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
5986 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
5987 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
5989 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
5990 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
5991 {"consistent_not", 0, 0, consistent_tests
},
5992 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
5993 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
5994 {"ketama_compat", 0, 0, ketama_compatibility
},
5995 {"test_hashes", 0, 0, hash_tests
},
5996 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
5997 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
5998 {"regression", 0, 0, regression_tests
},
5999 {"behaviors", 0, 0, behavior_tests
},
6000 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6001 {"error_conditions", 0, 0, error_conditions
},
6002 {"parser", 0, 0, parser_tests
},
6003 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6004 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6005 {"touch", 0, 0, touch_tests
},
6009 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
6011 #include "tests/libmemcached_world.h"
6013 void get_world(Framework
*world
)
6015 world
->collections
= collection
;
6017 world
->_create
= (test_callback_create_fn
*)world_create
;
6018 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6020 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6021 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6022 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6023 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6024 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6026 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6027 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6029 world
->set_runner(&defualt_libmemcached_runner
);
6031 world
->set_socket();