1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 #include <libtest/test.hpp>
45 #include <libmemcached-1.0/memcached.h>
46 #include <libmemcached/is.h>
47 #include <libmemcached/server_instance.h>
49 #include <libhashkit-1.0/hashkit.h>
55 #include <semaphore.h>
59 #include <sys/types.h>
64 #include <libtest/server.h>
66 #include "clients/generator.h"
67 #include "clients/execute.h"
69 #define SMALL_STRING_LEN 1024
71 #include <libtest/test.hpp>
73 #include "tests/basic.h"
74 #include "tests/debug.h"
75 #include "tests/deprecated.h"
76 #include "tests/error_conditions.h"
77 #include "tests/exist.h"
78 #include "tests/ketama.h"
79 #include "tests/namespace.h"
80 #include "tests/parser.h"
81 #include "tests/libmemcached-1.0/dump.h"
82 #include "tests/libmemcached-1.0/stat.h"
83 #include "tests/touch.h"
84 #include "tests/callbacks.h"
85 #include "tests/pool.h"
86 #include "tests/print.h"
87 #include "tests/replication.h"
88 #include "tests/server_add.h"
89 #include "tests/virtual_buckets.h"
91 using namespace libtest
;
93 #include <libmemcached/util.h>
95 #include "tests/hash_results.h"
97 #define GLOBAL_COUNT 10000
98 #define GLOBAL2_COUNT 100
99 #define SERVERS_TO_CREATE 5
100 static uint32_t global_count
= GLOBAL2_COUNT
;
102 static pairs_st
*global_pairs
;
103 static const char *global_keys
[GLOBAL_COUNT
];
104 static size_t global_keys_length
[GLOBAL_COUNT
];
107 @note This should be testing to see if the server really supports the binary protocol.
109 static test_return_t
pre_binary(memcached_st
*memc
)
111 test_skip(true, libmemcached_util_version_check(memc
, 1, 4, 4));
112 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
117 static memcached_return_t
return_value_based_on_buffering(memcached_st
*memc
)
119 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
))
121 return MEMCACHED_BUFFERED
;
124 return MEMCACHED_SUCCESS
;
127 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
130 * I only want to hit _one_ server so I know the number of requests I'm
131 * sending in the pipeline.
133 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
135 char server_string
[1024];
136 int server_string_length
;
139 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
140 memcached_server_name(instance
), int(memcached_server_port(instance
)),
145 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
146 memcached_server_name(instance
), int(memcached_server_port(instance
)));
149 if (server_string_length
<= 0)
155 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, buffer
, sizeof(buffer
))))
157 Error
<< "Failed to parse " << server_string_length
;
161 return memcached(server_string
, server_string_length
);
165 static test_return_t
init_test(memcached_st
*not_used
)
170 (void)memcached_create(&memc
);
171 memcached_free(&memc
);
176 #define TEST_PORT_COUNT 7
177 in_port_t test_ports
[TEST_PORT_COUNT
];
179 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
180 const memcached_server_st
*server
,
184 size_t bigger
= *((size_t *)(context
));
186 assert(bigger
<= memcached_server_port(server
));
187 *((size_t *)(context
))= memcached_server_port(server
);
189 return MEMCACHED_SUCCESS
;
192 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
193 const memcached_server_st
*instance
,
197 FILE *stream
= (FILE *)context
;
200 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
201 memcached_server_name(instance
),
202 memcached_server_port(instance
),
203 instance
->major_version
,
204 instance
->minor_version
,
205 instance
->micro_version
);
207 return MEMCACHED_SUCCESS
;
210 static test_return_t
server_sort_test(memcached_st
*ptr
)
212 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
214 memcached_return_t rc
;
215 memcached_server_fn callbacks
[1];
216 memcached_st
*local_memc
;
219 local_memc
= memcached_create(NULL
);
220 test_true(local_memc
);
221 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
223 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
225 test_ports
[x
]= (in_port_t
)random() % 64000;
226 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
227 test_compare(memcached_server_count(local_memc
), x
+1);
229 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
231 test_compare(MEMCACHED_SUCCESS
, rc
);
234 callbacks
[0]= server_display_function
;
235 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
238 memcached_free(local_memc
);
243 static test_return_t
server_sort2_test(memcached_st
*ptr
)
245 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
246 memcached_server_fn callbacks
[1];
247 memcached_st
*local_memc
;
248 memcached_server_instance_st instance
;
251 local_memc
= memcached_create(NULL
);
252 test_true(local_memc
);
253 test_compare(MEMCACHED_SUCCESS
,
254 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
256 test_compare(MEMCACHED_SUCCESS
,
257 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
258 instance
= memcached_server_instance_by_position(local_memc
, 0);
259 test_compare(in_port_t(43043), memcached_server_port(instance
));
261 test_compare(MEMCACHED_SUCCESS
,
262 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
264 instance
= memcached_server_instance_by_position(local_memc
, 0);
265 test_compare(in_port_t(43042), memcached_server_port(instance
));
267 instance
= memcached_server_instance_by_position(local_memc
, 1);
268 test_compare(in_port_t(43043), memcached_server_port(instance
));
270 callbacks
[0]= server_display_function
;
271 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
274 memcached_free(local_memc
);
279 static test_return_t
memcached_server_remove_test(memcached_st
*)
281 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";
284 test_compare(MEMCACHED_SUCCESS
,
285 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
286 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
289 memcached_server_fn callbacks
[1];
290 callbacks
[0]= server_print_callback
;
291 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
293 memcached_free(memc
);
298 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
299 const memcached_server_st
*server
,
303 uint32_t x
= *((uint32_t *)(context
));
305 if (! (test_ports
[x
] == server
->port
))
307 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
308 return MEMCACHED_FAILURE
;
311 *((uint32_t *)(context
))= ++x
;
313 return MEMCACHED_SUCCESS
;
316 static test_return_t
server_unsort_test(memcached_st
*ptr
)
318 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
319 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
320 memcached_server_fn callbacks
[1];
321 memcached_st
*local_memc
;
324 local_memc
= memcached_create(NULL
);
325 test_true(local_memc
);
327 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
329 test_ports
[x
]= (in_port_t
)(random() % 64000);
330 test_compare(MEMCACHED_SUCCESS
,
331 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
332 test_compare(memcached_server_count(local_memc
), x
+1);
334 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
338 callbacks
[0]= server_display_unsort_function
;
339 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
341 /* Now we sort old data! */
342 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
343 callbacks
[0]= server_display_function
;
344 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
347 memcached_free(local_memc
);
352 static test_return_t
allocation_test(memcached_st
*not_used
)
356 memc
= memcached_create(NULL
);
358 memcached_free(memc
);
363 static test_return_t
clone_test(memcached_st
*memc
)
367 memcached_st
*memc_clone
;
368 memc_clone
= memcached_clone(NULL
, NULL
);
369 test_true(memc_clone
);
370 memcached_free(memc_clone
);
373 /* Can we init from null? */
375 memcached_st
*memc_clone
;
376 memc_clone
= memcached_clone(NULL
, memc
);
377 test_true(memc_clone
);
380 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
381 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
382 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
383 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
386 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
387 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
388 test_true(memc_clone
->distribution
== memc
->distribution
);
389 { // Test all of the flags
390 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
391 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
392 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
393 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
394 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
395 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
396 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
397 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
398 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
399 test_true(memc_clone
->flags
.reply
== memc
->flags
.reply
);
400 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
401 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
402 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
404 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
405 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
406 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
407 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
408 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
409 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
410 test_true(memc_clone
->on_clone
== memc
->on_clone
);
411 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
412 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
413 test_true(memc_clone
->recv_size
== memc
->recv_size
);
414 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
415 test_true(memc_clone
->send_size
== memc
->send_size
);
416 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
417 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
418 test_true(memc_clone
->user_data
== memc
->user_data
);
420 memcached_free(memc_clone
);
423 /* Can we init from struct? */
425 memcached_st declared_clone
;
426 memcached_st
*memc_clone
;
427 memset(&declared_clone
, 0 , sizeof(memcached_st
));
428 memc_clone
= memcached_clone(&declared_clone
, NULL
);
429 test_true(memc_clone
);
430 memcached_free(memc_clone
);
433 /* Can we init from struct? */
435 memcached_st declared_clone
;
436 memcached_st
*memc_clone
;
437 memset(&declared_clone
, 0 , sizeof(memcached_st
));
438 memc_clone
= memcached_clone(&declared_clone
, memc
);
439 test_true(memc_clone
);
440 memcached_free(memc_clone
);
446 static test_return_t
userdata_test(memcached_st
*memc
)
449 test_false(memcached_set_user_data(memc
, foo
));
450 test_true(memcached_get_user_data(memc
) == foo
);
451 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
456 static test_return_t
connection_test(memcached_st
*memc
)
458 test_compare(MEMCACHED_SUCCESS
,
459 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
464 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
466 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
468 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
470 test_compare(37, int(MEMCACHED_BEHAVIOR_MAX
));
475 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
477 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
479 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
481 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
486 static test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
488 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
489 982370485U, 1263635348U, 4242906218U, 3829656100U,
490 1891735253U, 334139633U, 2257084983U, 3351789013U,
491 13199785U, 2542027183U, 1097051614U, 199566778U,
492 2748246961U, 2465192557U, 1664094137U, 2405439045U,
493 1842224848U, 692413798U, 3479807801U, 919913813U,
494 4269430871U, 610793021U, 527273862U, 1437122909U,
495 2300930706U, 2943759320U, 674306647U, 2400528935U,
496 54481931U, 4186304426U, 1741088401U, 2979625118U,
497 4159057246U, 3425930182U, 2593724503U, 1868899624U,
498 1769812374U, 2302537950U, 1110330676U, 3365377466U,
499 1336171666U, 3021258493U, 2334992265U, 3861994737U,
500 3582734124U, 3365377466U };
502 // You have updated the memcache_error messages but not updated docs/tests.
503 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
506 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
507 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
508 MEMCACHED_HASH_JENKINS
);
509 if (values
[rc
] != hash_val
)
511 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
512 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
514 test_compare(values
[rc
], hash_val
);
516 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
521 static test_return_t
set_test(memcached_st
*memc
)
523 memcached_return_t rc
= memcached_set(memc
,
524 test_literal_param("foo"),
525 test_literal_param("when we sanitize"),
526 time_t(0), (uint32_t)0);
527 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
532 static test_return_t
append_test(memcached_st
*memc
)
534 memcached_return_t rc
;
535 const char *in_value
= "we";
539 test_compare(MEMCACHED_SUCCESS
,
540 memcached_flush(memc
, 0));
542 test_compare(MEMCACHED_SUCCESS
,
544 test_literal_param(__func__
),
545 in_value
, strlen(in_value
),
546 time_t(0), uint32_t(0)));
548 test_compare(MEMCACHED_SUCCESS
,
549 memcached_append(memc
,
550 test_literal_param(__func__
),
551 " the", strlen(" the"),
552 time_t(0), uint32_t(0)));
554 test_compare(MEMCACHED_SUCCESS
,
555 memcached_append(memc
,
556 test_literal_param(__func__
),
557 " people", strlen(" people"),
558 time_t(0), uint32_t(0)));
560 char *out_value
= memcached_get(memc
,
561 test_literal_param(__func__
),
562 &value_length
, &flags
, &rc
);
563 test_memcmp(out_value
, "we the people", strlen("we the people"));
564 test_compare(strlen("we the people"), value_length
);
565 test_compare(MEMCACHED_SUCCESS
, rc
);
571 static test_return_t
append_binary_test(memcached_st
*memc
)
573 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
575 test_compare(MEMCACHED_SUCCESS
,
576 memcached_flush(memc
, 0));
578 test_compare(MEMCACHED_SUCCESS
,
580 test_literal_param(__func__
),
582 time_t(0), uint32_t(0)));
585 for (uint32_t x
= 0; store_list
[x
] ; x
++)
587 test_compare(MEMCACHED_SUCCESS
,
588 memcached_append(memc
,
589 test_literal_param(__func__
),
590 (char *)&store_list
[x
], sizeof(uint32_t),
591 time_t(0), uint32_t(0)));
597 memcached_return_t rc
;
598 uint32_t *value
= (uint32_t *)memcached_get(memc
,
599 test_literal_param(__func__
),
600 &value_length
, &flags
, &rc
);
601 test_compare(value_length
, sizeof(uint32_t) * count
);
602 test_compare(MEMCACHED_SUCCESS
, rc
);
604 for (uint32_t counter
= count
, *ptr
= value
; counter
; counter
--)
606 test_compare(*ptr
, store_list
[count
- counter
]);
614 static test_return_t
cas2_test(memcached_st
*memc
)
616 const char *keys
[]= {"fudge", "son", "food"};
617 size_t key_length
[]= {5, 3, 4};
618 const char *value
= "we the people";
619 size_t value_length
= strlen("we the people");
621 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
623 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
625 for (uint32_t x
= 0; x
< 3; x
++)
627 test_compare(MEMCACHED_SUCCESS
,
628 memcached_set(memc
, keys
[x
], key_length
[x
],
629 keys
[x
], key_length
[x
],
630 time_t(50), uint32_t(9)));
633 test_compare(MEMCACHED_SUCCESS
,
634 memcached_mget(memc
, keys
, key_length
, 3));
636 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
639 memcached_return_t rc
;
640 results
= memcached_fetch_result(memc
, results
, &rc
);
642 test_true(results
->item_cas
);
643 test_compare(MEMCACHED_SUCCESS
, rc
);
644 test_true(memcached_result_cas(results
));
646 test_memcmp(value
, "we the people", strlen("we the people"));
647 test_compare(strlen("we the people"), value_length
);
648 test_compare(MEMCACHED_SUCCESS
, rc
);
650 memcached_result_free(results
);
655 static test_return_t
cas_test(memcached_st
*memc
)
657 const char* keys
[2] = { __func__
, NULL
};
658 size_t keylengths
[2] = { strlen(__func__
), 0 };
660 memcached_result_st results_obj
;
662 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
664 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
666 test_compare(MEMCACHED_SUCCESS
,
668 test_literal_param(__func__
),
669 test_literal_param("we the people"),
670 (time_t)0, (uint32_t)0));
672 test_compare(MEMCACHED_SUCCESS
,
673 memcached_mget(memc
, keys
, keylengths
, 1));
675 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
678 memcached_return_t rc
;
679 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
681 test_compare(MEMCACHED_SUCCESS
, rc
);
682 test_true(memcached_result_cas(results
));
683 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
684 test_compare(test_literal_param_size("we the people"),
685 strlen(memcached_result_value(results
)));
687 uint64_t cas
= memcached_result_cas(results
);
690 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
691 test_true(rc
== MEMCACHED_END
);
692 test_true(results
== NULL
);
695 test_compare(MEMCACHED_SUCCESS
,
697 test_literal_param(__func__
),
698 test_literal_param("change the value"),
702 * The item will have a new cas value, so try to set it again with the old
703 * value. This should fail!
705 test_compare(MEMCACHED_DATA_EXISTS
,
707 test_literal_param(__func__
),
708 test_literal_param("change the value"),
711 memcached_result_free(&results_obj
);
716 static test_return_t
prepend_test(memcached_st
*memc
)
718 const char *key
= "fig";
719 const char *value
= "people";
721 test_compare(MEMCACHED_SUCCESS
,
722 memcached_flush(memc
, 0));
724 test_compare(MEMCACHED_SUCCESS
,
725 memcached_set(memc
, key
, strlen(key
),
726 value
, strlen(value
),
727 time_t(0), uint32_t(0)));
729 test_compare(MEMCACHED_SUCCESS
,
730 memcached_prepend(memc
, key
, strlen(key
),
731 "the ", strlen("the "),
732 time_t(0), uint32_t(0)));
734 test_compare(MEMCACHED_SUCCESS
,
735 memcached_prepend(memc
, key
, strlen(key
),
736 "we ", strlen("we "),
737 time_t(0), uint32_t(0)));
741 memcached_return_t rc
;
742 char *out_value
= memcached_get(memc
, key
, strlen(key
),
743 &value_length
, &flags
, &rc
);
744 test_memcmp(out_value
, "we the people", strlen("we the people"));
745 test_compare(strlen("we the people"), value_length
);
746 test_compare(MEMCACHED_SUCCESS
, rc
);
753 Set the value, then quit to make sure it is flushed.
754 Come back in and test that add fails.
756 static test_return_t
add_test(memcached_st
*memc
)
758 test_compare_hint(return_value_based_on_buffering(memc
),
760 test_literal_param(__func__
),
761 test_literal_param("when we sanitize"),
762 time_t(0), uint32_t(0)),
763 memcached_last_error_message(memc
));
765 memcached_quit(memc
);
767 test_compare_hint(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
769 test_literal_param(__func__
),
770 test_literal_param("try something else"),
771 time_t(0), uint32_t(0)),
772 memcached_last_error_message(memc
));
778 ** There was a problem of leaking filedescriptors in the initial release
779 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
780 ** systems it seems that the kernel is slow on reclaiming the resources
781 ** because the connects starts to time out (the test doesn't do much
782 ** anyway, so just loop 10 iterations)
784 static test_return_t
add_wrapper(memcached_st
*memc
)
786 unsigned int max
= 10000;
794 for (uint32_t x
= 0; x
< max
; x
++)
800 static test_return_t
replace_test(memcached_st
*memc
)
802 test_compare(return_value_based_on_buffering(memc
),
804 test_literal_param(__func__
),
805 test_literal_param("when we sanitize"),
806 time_t(0), uint32_t(0)));
808 test_compare(MEMCACHED_SUCCESS
,
809 memcached_replace(memc
,
810 test_literal_param(__func__
),
811 test_literal_param("first we insert some data"),
812 time_t(0), uint32_t(0)));
817 static test_return_t
delete_test(memcached_st
*memc
)
819 test_compare(return_value_based_on_buffering(memc
),
821 test_literal_param(__func__
),
822 test_literal_param("when we sanitize"),
823 time_t(0), uint32_t(0)));
825 test_compare_hint(return_value_based_on_buffering(memc
),
826 memcached_delete(memc
,
827 test_literal_param(__func__
),
829 memcached_last_error_message(memc
));
834 static test_return_t
flush_test(memcached_st
*memc
)
836 uint64_t query_id
= memcached_query_id(memc
);
837 test_compare(MEMCACHED_SUCCESS
,
838 memcached_flush(memc
, 0));
839 test_compare(query_id
+1, memcached_query_id(memc
));
844 static memcached_return_t
server_function(const memcached_st
*,
845 const memcached_server_st
*,
849 return MEMCACHED_SUCCESS
;
852 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
855 strncpy(context
, "foo bad", sizeof(context
));
856 memcached_server_fn callbacks
[1];
858 callbacks
[0]= server_function
;
859 memcached_server_cursor(memc
, callbacks
, context
, 1);
863 static test_return_t
bad_key_test(memcached_st
*memc
)
865 memcached_return_t rc
;
866 const char *key
= "foo bad";
869 uint64_t query_id
= memcached_query_id(memc
);
871 // Just skip if we are in binary mode.
872 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
874 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
876 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
877 test_true(memc_clone
);
879 query_id
= memcached_query_id(memc_clone
);
880 test_compare(MEMCACHED_SUCCESS
,
881 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
882 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
884 /* All keys are valid in the binary protocol (except for length) */
885 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == false)
887 uint64_t before_query_id
= memcached_query_id(memc_clone
);
889 size_t string_length
;
890 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
891 &string_length
, &flags
, &rc
);
892 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
893 test_zero(string_length
);
896 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
898 query_id
= memcached_query_id(memc_clone
);
899 test_compare(MEMCACHED_SUCCESS
,
900 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
901 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
903 size_t string_length
;
904 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
905 &string_length
, &flags
, &rc
);
906 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
907 test_zero(string_length
);
911 /* Test multi key for bad keys */
912 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
913 size_t key_lengths
[] = { 7, 7, 7 };
914 query_id
= memcached_query_id(memc_clone
);
915 test_compare(MEMCACHED_SUCCESS
,
916 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
917 test_compare(query_id
, memcached_query_id(memc_clone
));
919 query_id
= memcached_query_id(memc_clone
);
920 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
921 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
922 test_compare(query_id
+1, memcached_query_id(memc_clone
));
924 query_id
= memcached_query_id(memc_clone
);
925 // Grouping keys are not required to follow normal key behaviors
926 test_compare(MEMCACHED_SUCCESS
,
927 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
928 test_compare(query_id
+1, memcached_query_id(memc_clone
));
930 /* The following test should be moved to the end of this function when the
931 memcached server is updated to allow max size length of the keys in the
934 test_compare(MEMCACHED_SUCCESS
,
935 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
937 std::vector
<char> longkey
;
939 std::vector
<char>::iterator it
= longkey
.begin();
940 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
943 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
945 size_t string_length
;
947 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
948 test_compare(MEMCACHED_NOTFOUND
, rc
);
949 test_zero(string_length
);
951 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
952 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
953 test_zero(string_length
);
957 /* Make sure zero length keys are marked as bad */
959 test_compare(MEMCACHED_SUCCESS
,
960 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
961 size_t string_length
;
962 char *string
= memcached_get(memc_clone
, key
, 0,
963 &string_length
, &flags
, &rc
);
964 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
965 test_zero(string_length
);
969 memcached_free(memc_clone
);
974 #define READ_THROUGH_VALUE "set for me"
975 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
978 memcached_result_st
*result
)
980 (void)memc
;(void)key
;(void)key_length
;
981 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
984 #ifndef __INTEL_COMPILER
985 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
988 static test_return_t
read_through(memcached_st
*memc
)
990 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
992 size_t string_length
;
994 memcached_return_t rc
;
995 char *string
= memcached_get(memc
,
996 test_literal_param(__func__
),
997 &string_length
, &flags
, &rc
);
999 test_compare(MEMCACHED_NOTFOUND
, rc
);
1000 test_false(string_length
);
1003 test_compare(MEMCACHED_SUCCESS
,
1004 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1006 string
= memcached_get(memc
,
1007 test_literal_param(__func__
),
1008 &string_length
, &flags
, &rc
);
1010 test_compare(MEMCACHED_SUCCESS
, rc
);
1011 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1012 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1013 test_strcmp(READ_THROUGH_VALUE
, string
);
1016 string
= memcached_get(memc
,
1017 test_literal_param(__func__
),
1018 &string_length
, &flags
, &rc
);
1020 test_compare(MEMCACHED_SUCCESS
, rc
);
1022 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1023 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1024 test_strcmp(READ_THROUGH_VALUE
, string
);
1027 return TEST_SUCCESS
;
1030 static test_return_t
get_test(memcached_st
*memc
)
1032 memcached_return_t rc
;
1034 size_t string_length
;
1037 uint64_t query_id
= memcached_query_id(memc
);
1038 rc
= memcached_delete(memc
,
1039 test_literal_param(__func__
),
1041 test_true_got(rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_NOTFOUND
, memcached_last_error_message(memc
));
1042 test_compare(query_id
+1, memcached_query_id(memc
));
1044 string
= memcached_get(memc
,
1045 test_literal_param(__func__
),
1046 &string_length
, &flags
, &rc
);
1048 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1049 test_false(string_length
);
1052 return TEST_SUCCESS
;
1055 static test_return_t
get_test2(memcached_st
*memc
)
1057 const char *value
= "when we sanitize";
1059 uint64_t query_id
= memcached_query_id(memc
);
1060 test_compare(return_value_based_on_buffering(memc
),
1062 test_literal_param(__func__
),
1063 value
, strlen(value
),
1064 time_t(0), uint32_t(0)));
1065 test_compare(query_id
+1, memcached_query_id(memc
));
1067 query_id
= memcached_query_id(memc
);
1068 test_true(query_id
);
1071 size_t string_length
;
1072 memcached_return_t rc
;
1073 char *string
= memcached_get(memc
,
1074 test_literal_param(__func__
),
1075 &string_length
, &flags
, &rc
);
1076 test_compare(query_id
+1, memcached_query_id(memc
));
1078 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1079 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1081 test_compare(strlen(value
), string_length
);
1082 test_memcmp(string
, value
, string_length
);
1086 return TEST_SUCCESS
;
1089 static test_return_t
set_test2(memcached_st
*memc
)
1091 for (uint32_t x
= 0; x
< 10; x
++)
1093 test_compare(return_value_based_on_buffering(memc
),
1095 test_literal_param("foo"),
1096 test_literal_param("train in the brain"),
1097 time_t(0), uint32_t(0)));
1100 return TEST_SUCCESS
;
1103 static test_return_t
set_test3(memcached_st
*memc
)
1105 size_t value_length
= 8191;
1107 std::vector
<char> value
;
1108 value
.reserve(value_length
);
1109 for (uint32_t x
= 0; x
< value_length
; x
++)
1111 value
.push_back(char(x
% 127));
1114 /* The dump test relies on there being at least 32 items in memcached */
1115 for (uint32_t x
= 0; x
< 32; x
++)
1119 snprintf(key
, sizeof(key
), "foo%u", x
);
1121 uint64_t query_id
= memcached_query_id(memc
);
1122 test_compare_hint(return_value_based_on_buffering(memc
),
1123 memcached_set(memc
, key
, strlen(key
),
1124 &value
[0], value
.size(),
1125 time_t(0), uint32_t(0)),
1126 memcached_last_error_message(memc
));
1127 test_compare(query_id
+1, memcached_query_id(memc
));
1130 return TEST_SUCCESS
;
1133 static test_return_t
get_test3(memcached_st
*memc
)
1135 size_t value_length
= 8191;
1137 std::vector
<char> value
;
1138 value
.reserve(value_length
);
1139 for (uint32_t x
= 0; x
< value_length
; x
++)
1141 value
.push_back(char(x
% 127));
1144 test_compare_hint(return_value_based_on_buffering(memc
),
1146 test_literal_param(__func__
),
1147 &value
[0], value
.size(),
1148 time_t(0), uint32_t(0)),
1149 memcached_last_error_message(memc
));
1151 size_t string_length
;
1153 memcached_return_t rc
;
1154 char *string
= memcached_get(memc
,
1155 test_literal_param(__func__
),
1156 &string_length
, &flags
, &rc
);
1158 test_compare(MEMCACHED_SUCCESS
, rc
);
1160 test_compare(value
.size(), string_length
);
1161 test_memcmp(string
, &value
[0], string_length
);
1165 return TEST_SUCCESS
;
1168 static test_return_t
get_test4(memcached_st
*memc
)
1170 size_t value_length
= 8191;
1172 std::vector
<char> value
;
1173 value
.reserve(value_length
);
1174 for (uint32_t x
= 0; x
< value_length
; x
++)
1176 value
.push_back(char(x
% 127));
1179 test_compare_hint(return_value_based_on_buffering(memc
),
1181 test_literal_param(__func__
),
1182 &value
[0], value
.size(),
1183 time_t(0), uint32_t(0)),
1184 memcached_last_error_message(memc
));
1186 for (uint32_t x
= 0; x
< 10; x
++)
1189 size_t string_length
;
1190 memcached_return_t rc
;
1191 char *string
= memcached_get(memc
,
1192 test_literal_param(__func__
),
1193 &string_length
, &flags
, &rc
);
1195 test_compare(MEMCACHED_SUCCESS
, rc
);
1197 test_compare(value
.size(), string_length
);
1198 test_memcmp(string
, &value
[0], string_length
);
1202 return TEST_SUCCESS
;
1206 * This test verifies that memcached_read_one_response doesn't try to
1207 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1208 * responses before you execute a storage command.
1210 static test_return_t
get_test5(memcached_st
*memc
)
1213 ** Request the same key twice, to ensure that we hash to the same server
1214 ** (so that we have multiple response values queued up) ;-)
1216 const char *keys
[]= { "key", "key" };
1217 size_t lengths
[]= { 3, 3 };
1221 test_compare_hint(return_value_based_on_buffering(memc
),
1222 memcached_set(memc
, keys
[0], lengths
[0],
1223 keys
[0], lengths
[0],
1224 time_t(0), uint32_t(0)),
1225 memcached_last_error_message(memc
));
1226 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1228 memcached_result_st results_obj
;
1229 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1232 memcached_return_t rc
;
1233 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1236 memcached_result_free(&results_obj
);
1238 /* Don't read out the second result, but issue a set instead.. */
1239 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1241 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1242 &rlen
, &flags
, &rc
);
1244 test_compare(MEMCACHED_NOTFOUND
, rc
);
1245 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1247 test_compare(MEMCACHED_SUCCESS
, rc
);
1250 return TEST_SUCCESS
;
1253 static test_return_t
mget_end(memcached_st
*memc
)
1255 const char *keys
[]= { "foo", "foo2" };
1256 size_t lengths
[]= { 3, 4 };
1257 const char *values
[]= { "fjord", "41" };
1260 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1262 test_compare(MEMCACHED_SUCCESS
,
1264 keys
[x
], lengths
[x
],
1265 values
[x
], strlen(values
[x
]),
1266 time_t(0), uint32_t(0)));
1270 size_t string_length
;
1273 // retrieve both via mget
1274 test_compare(MEMCACHED_SUCCESS
,
1275 memcached_mget(memc
,
1277 test_array_length(keys
)));
1279 char key
[MEMCACHED_MAX_KEY
];
1281 memcached_return_t rc
;
1283 // this should get both
1284 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1286 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1288 test_compare(MEMCACHED_SUCCESS
, rc
);
1290 if (key_length
== 4)
1295 test_compare(string_length
, strlen(values
[val
]));
1296 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1300 // this should indicate end
1301 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1302 test_compare(MEMCACHED_END
, rc
);
1306 test_compare(MEMCACHED_SUCCESS
,
1307 memcached_mget(memc
, keys
, lengths
, 1));
1309 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1310 test_compare(key_length
, lengths
[0]);
1311 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1312 test_compare(string_length
, strlen(values
[0]));
1313 test_true(strncmp(values
[0], string
, string_length
) == 0);
1314 test_compare(MEMCACHED_SUCCESS
, rc
);
1317 // this should indicate end
1318 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1319 test_compare(MEMCACHED_END
, rc
);
1322 return TEST_SUCCESS
;
1325 /* Do not copy the style of this code, I just access hosts to testthis function */
1326 static test_return_t
stats_servername_test(memcached_st
*memc
)
1328 memcached_stat_st memc_stat
;
1329 memcached_server_instance_st instance
=
1330 memcached_server_instance_by_position(memc
, 0);
1332 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1334 return TEST_SKIPPED
;
1337 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1338 memcached_server_name(instance
),
1339 memcached_server_port(instance
)));
1341 return TEST_SUCCESS
;
1344 static test_return_t
increment_test(memcached_st
*memc
)
1346 uint64_t new_number
;
1348 test_compare(MEMCACHED_SUCCESS
,
1350 test_literal_param("number"),
1351 test_literal_param("0"),
1352 (time_t)0, (uint32_t)0));
1354 test_compare(MEMCACHED_SUCCESS
,
1355 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1356 test_compare(uint64_t(1), new_number
);
1358 test_compare(MEMCACHED_SUCCESS
,
1359 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1360 test_compare(uint64_t(2), new_number
);
1362 return TEST_SUCCESS
;
1365 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1367 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1369 uint64_t new_number
;
1370 uint64_t initial
= 0;
1372 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1374 test_compare(MEMCACHED_SUCCESS
,
1375 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1376 test_compare(new_number
, initial
);
1378 test_compare(MEMCACHED_SUCCESS
,
1379 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1380 test_compare(new_number
, (initial
+1));
1382 return TEST_SUCCESS
;
1385 static test_return_t
decrement_test(memcached_st
*memc
)
1387 test_compare(return_value_based_on_buffering(memc
),
1389 test_literal_param(__func__
),
1390 test_literal_param("3"),
1391 time_t(0), uint32_t(0)));
1392 // Make sure we flush the value we just set
1393 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1395 uint64_t new_number
;
1396 test_compare(MEMCACHED_SUCCESS
,
1397 memcached_decrement(memc
,
1398 test_literal_param(__func__
),
1400 test_compare(uint64_t(2), new_number
);
1402 test_compare(MEMCACHED_SUCCESS
,
1403 memcached_decrement(memc
,
1404 test_literal_param(__func__
),
1406 test_compare(uint64_t(1), new_number
);
1408 return TEST_SUCCESS
;
1411 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1413 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1415 uint64_t initial
= 3;
1417 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1419 uint64_t new_number
;
1420 test_compare(MEMCACHED_SUCCESS
,
1421 memcached_decrement_with_initial(memc
,
1422 test_literal_param(__func__
),
1425 test_compare(new_number
, initial
);
1427 test_compare(MEMCACHED_SUCCESS
,
1428 memcached_decrement_with_initial(memc
,
1429 test_literal_param(__func__
),
1432 test_compare(new_number
, (initial
- 1));
1434 return TEST_SUCCESS
;
1437 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1439 const char *master_key
= "foo";
1440 const char *key
= "number";
1441 const char *value
= "0";
1443 test_compare(return_value_based_on_buffering(memc
),
1444 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1446 value
, strlen(value
),
1447 time_t(0), uint32_t(0)));
1449 // Make sure we flush the value we just set
1450 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1452 uint64_t new_number
;
1453 test_compare(MEMCACHED_SUCCESS
,
1454 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1455 key
, strlen(key
), 1, &new_number
));
1456 test_compare(uint64_t(1), new_number
);
1458 test_compare(MEMCACHED_SUCCESS
,
1459 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1460 key
, strlen(key
), 1, &new_number
));
1461 test_compare(uint64_t(2), new_number
);
1463 return TEST_SUCCESS
;
1466 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1468 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1470 uint64_t new_number
;
1471 const char *master_key
= "foo";
1472 const char *key
= "number";
1473 uint64_t initial
= 0;
1475 test_compare(MEMCACHED_SUCCESS
,
1476 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1478 1, initial
, 0, &new_number
));
1479 test_compare(new_number
, initial
);
1481 test_compare(MEMCACHED_SUCCESS
,
1482 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1484 1, initial
, 0, &new_number
));
1485 test_compare(new_number
, (initial
+1));
1487 return TEST_SUCCESS
;
1490 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1492 uint64_t new_number
;
1493 const char *value
= "3";
1495 test_compare(return_value_based_on_buffering(memc
),
1496 memcached_set_by_key(memc
,
1497 test_literal_param("foo"),
1498 test_literal_param("number"),
1499 value
, strlen(value
),
1500 (time_t)0, (uint32_t)0));
1502 test_compare(MEMCACHED_SUCCESS
,
1503 memcached_decrement_by_key(memc
,
1504 test_literal_param("foo"),
1505 test_literal_param("number"),
1507 test_compare(uint64_t(2), new_number
);
1509 test_compare(MEMCACHED_SUCCESS
,
1510 memcached_decrement_by_key(memc
,
1511 test_literal_param("foo"),
1512 test_literal_param("number"),
1514 test_compare(uint64_t(1), new_number
);
1516 return TEST_SUCCESS
;
1519 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1521 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1523 uint64_t new_number
;
1524 uint64_t initial
= 3;
1526 test_compare(MEMCACHED_SUCCESS
,
1527 memcached_decrement_with_initial_by_key(memc
,
1528 test_literal_param("foo"),
1529 test_literal_param("number"),
1530 1, initial
, 0, &new_number
));
1531 test_compare(new_number
, initial
);
1533 test_compare(MEMCACHED_SUCCESS
,
1534 memcached_decrement_with_initial_by_key(memc
,
1535 test_literal_param("foo"),
1536 test_literal_param("number"),
1537 1, initial
, 0, &new_number
));
1538 test_compare(new_number
, (initial
- 1));
1540 return TEST_SUCCESS
;
1542 static test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1544 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1546 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1548 test_compare(return_value_based_on_buffering(memc
),
1550 test_literal_param("number"),
1551 test_literal_param("0"),
1552 (time_t)0, (uint32_t)0));
1554 uint64_t new_number
;
1555 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1556 test_literal_param("number"),
1558 test_compare(uint64_t(1), new_number
);
1560 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1561 test_literal_param("number"),
1563 test_compare(uint64_t(2), new_number
);
1565 return TEST_SUCCESS
;
1568 static test_return_t
quit_test(memcached_st
*memc
)
1570 const char *value
= "sanford and sun";
1572 test_compare(return_value_based_on_buffering(memc
),
1574 test_literal_param(__func__
),
1575 value
, strlen(value
),
1576 (time_t)10, (uint32_t)3));
1577 memcached_quit(memc
);
1579 test_compare(return_value_based_on_buffering(memc
),
1581 test_literal_param(__func__
),
1582 value
, strlen(value
),
1583 (time_t)50, (uint32_t)9));
1585 return TEST_SUCCESS
;
1588 static test_return_t
mget_result_test(memcached_st
*memc
)
1590 const char *keys
[]= {"fudge", "son", "food"};
1591 size_t key_length
[]= {5, 3, 4};
1593 memcached_result_st results_obj
;
1594 memcached_result_st
*results
;
1596 results
= memcached_result_create(memc
, &results_obj
);
1598 test_true(&results_obj
== results
);
1600 /* We need to empty the server before continueing test */
1601 test_compare(MEMCACHED_SUCCESS
,
1602 memcached_flush(memc
, 0));
1604 test_compare(MEMCACHED_SUCCESS
,
1605 memcached_mget(memc
, keys
, key_length
, 3));
1607 memcached_return_t rc
;
1608 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1613 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1614 test_false(results
);
1615 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1617 for (uint32_t x
= 0; x
< 3; x
++)
1619 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1620 keys
[x
], key_length
[x
],
1621 (time_t)50, (uint32_t)9);
1622 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1625 test_compare(MEMCACHED_SUCCESS
,
1626 memcached_mget(memc
, keys
, key_length
, 3));
1628 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1631 test_true(&results_obj
== results
);
1632 test_compare(MEMCACHED_SUCCESS
, rc
);
1633 test_memcmp(memcached_result_key_value(results
),
1634 memcached_result_value(results
),
1635 memcached_result_length(results
));
1636 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1639 memcached_result_free(&results_obj
);
1641 return TEST_SUCCESS
;
1644 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1646 const char *keys
[]= {"fudge", "son", "food"};
1647 size_t key_length
[]= {5, 3, 4};
1649 memcached_result_st
*results
;
1651 /* We need to empty the server before continueing test */
1652 test_compare(MEMCACHED_SUCCESS
,
1653 memcached_flush(memc
, 0));
1655 test_compare(MEMCACHED_SUCCESS
,
1656 memcached_mget(memc
, keys
, key_length
, 3));
1658 memcached_return_t rc
;
1659 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1663 test_false(results
);
1664 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1666 for (uint32_t x
= 0; x
< 3; x
++)
1668 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1669 keys
[x
], key_length
[x
],
1670 (time_t)50, (uint32_t)9);
1671 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1674 test_compare(MEMCACHED_SUCCESS
,
1675 memcached_mget(memc
, keys
, key_length
, 3));
1678 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1681 test_compare(MEMCACHED_SUCCESS
, rc
);
1682 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1683 test_memcmp(memcached_result_key_value(results
),
1684 memcached_result_value(results
),
1685 memcached_result_length(results
));
1686 memcached_result_free(results
);
1690 return TEST_SUCCESS
;
1693 /* Count the results */
1694 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1696 size_t *counter
= (size_t *)context
;
1698 *counter
= *counter
+ 1;
1700 return MEMCACHED_SUCCESS
;
1703 static test_return_t
mget_result_function(memcached_st
*memc
)
1705 const char *keys
[]= {"fudge", "son", "food"};
1706 size_t key_length
[]= {5, 3, 4};
1708 memcached_execute_fn callbacks
[1];
1710 for (uint32_t x
= 0; x
< 3; x
++)
1712 test_compare(return_value_based_on_buffering(memc
),
1713 memcached_set(memc
, keys
[x
], key_length
[x
],
1714 keys
[x
], key_length
[x
],
1715 time_t(50), uint32_t(9)));
1717 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1718 memcached_quit(memc
);
1720 test_compare(MEMCACHED_SUCCESS
,
1721 memcached_mget(memc
, keys
, key_length
, 3));
1723 callbacks
[0]= &callback_counter
;
1726 test_compare(MEMCACHED_SUCCESS
,
1727 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1729 test_compare(size_t(3), counter
);
1731 return TEST_SUCCESS
;
1734 static test_return_t
mget_test(memcached_st
*memc
)
1736 const char *keys
[]= {"fudge", "son", "food"};
1737 size_t key_length
[]= {5, 3, 4};
1739 char return_key
[MEMCACHED_MAX_KEY
];
1740 size_t return_key_length
;
1742 size_t return_value_length
;
1744 test_compare(MEMCACHED_SUCCESS
,
1745 memcached_mget(memc
, keys
, key_length
, 3));
1748 memcached_return_t rc
;
1749 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1750 &return_value_length
, &flags
, &rc
)))
1752 test_true(return_value
);
1754 test_false(return_value
);
1755 test_zero(return_value_length
);
1756 test_compare(MEMCACHED_NOTFOUND
, rc
);
1758 for (uint32_t x
= 0; x
< 3; x
++)
1760 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1761 keys
[x
], key_length
[x
],
1762 (time_t)50, (uint32_t)9);
1763 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1765 test_compare(MEMCACHED_SUCCESS
,
1766 memcached_mget(memc
, keys
, key_length
, 3));
1769 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1770 &return_value_length
, &flags
, &rc
)))
1772 test_true(return_value
);
1773 test_compare(MEMCACHED_SUCCESS
, rc
);
1774 if (not memc
->_namespace
)
1776 test_compare(return_key_length
, return_value_length
);
1777 test_memcmp(return_value
, return_key
, return_value_length
);
1783 return TEST_SUCCESS
;
1786 static test_return_t
mget_execute(memcached_st
*original_memc
)
1788 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1790 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1793 size_t max_keys
= 20480;
1796 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1797 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1799 /* First add all of the items.. */
1800 char blob
[1024] = {0};
1802 for (size_t x
= 0; x
< max_keys
; ++x
)
1806 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1808 test_true(keys
[x
] != NULL
);
1809 uint64_t query_id
= memcached_query_id(memc
);
1810 memcached_return_t rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1811 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1812 test_compare(query_id
+1, memcached_query_id(memc
));
1815 /* Try to get all of them with a large multiget */
1817 memcached_execute_fn callbacks
[]= { &callback_counter
};
1818 test_compare(MEMCACHED_SUCCESS
,
1819 memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1820 max_keys
, callbacks
, &counter
, 1));
1823 uint64_t query_id
= memcached_query_id(memc
);
1824 test_compare(MEMCACHED_SUCCESS
,
1825 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1826 test_compare(query_id
, memcached_query_id(memc
));
1828 /* Verify that we got all of the items */
1829 test_true(counter
== max_keys
);
1832 /* Release all allocated resources */
1833 for (size_t x
= 0; x
< max_keys
; ++x
)
1840 memcached_free(memc
);
1842 return TEST_SUCCESS
;
1845 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1847 static test_return_t
key_setup(memcached_st
*memc
)
1849 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1851 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1853 return TEST_SUCCESS
;
1856 static test_return_t
key_teardown(memcached_st
*memc
)
1859 pairs_free(global_pairs
);
1861 return TEST_SUCCESS
;
1864 static test_return_t
block_add_regression(memcached_st
*memc
)
1866 /* First add all of the items.. */
1867 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1869 char blob
[1024] = {0};
1871 memcached_return_t rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1872 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
, memcached_strerror(NULL
, rc
));
1875 return TEST_SUCCESS
;
1878 static test_return_t
binary_add_regression(memcached_st
*memc
)
1880 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1881 test_return_t rc
= block_add_regression(memc
);
1886 static test_return_t
get_stats_keys(memcached_st
*memc
)
1890 memcached_stat_st memc_stat
;
1891 memcached_return_t rc
;
1893 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1894 test_compare(MEMCACHED_SUCCESS
, rc
);
1895 for (ptr
= stat_list
; *ptr
; ptr
++)
1900 return TEST_SUCCESS
;
1903 static test_return_t
version_string_test(memcached_st
*)
1905 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1907 return TEST_SUCCESS
;
1910 static test_return_t
get_stats(memcached_st
*memc
)
1912 memcached_return_t rc
;
1914 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1915 test_compare(MEMCACHED_SUCCESS
, rc
);
1916 test_true(memc_stat
);
1918 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1920 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1921 test_compare(MEMCACHED_SUCCESS
, rc
);
1922 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1927 memcached_stat_free(NULL
, memc_stat
);
1929 return TEST_SUCCESS
;
1932 static test_return_t
add_host_test(memcached_st
*memc
)
1934 char servername
[]= "0.example.com";
1936 memcached_return_t rc
;
1937 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1938 test_compare(1U, memcached_server_list_count(servers
));
1940 for (unsigned int x
= 2; x
< 20; x
++)
1942 char buffer
[SMALL_STRING_LEN
];
1944 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1945 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1947 test_compare(MEMCACHED_SUCCESS
, rc
);
1948 test_compare(x
, memcached_server_list_count(servers
));
1951 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1952 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1954 memcached_server_list_free(servers
);
1956 return TEST_SUCCESS
;
1959 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1961 memcached_return_t rc
;
1963 const char *key
= "not_found";
1964 size_t key_length
= test_literal_param_size("not_found");
1966 test_compare(MEMCACHED_SUCCESS
,
1967 memcached_mget(memc
, &key
, &key_length
, 1));
1969 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1971 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1973 memcached_result_free(result
);
1975 return TEST_SUCCESS
;
1978 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1980 return MEMCACHED_SUCCESS
;
1983 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1985 return MEMCACHED_SUCCESS
;
1988 static test_return_t
callback_test(memcached_st
*memc
)
1990 /* Test User Data */
1994 memcached_return_t rc
;
1996 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1997 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1998 test_true(*test_ptr
== x
);
2001 /* Test Clone Callback */
2003 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2004 void *clone_cb_ptr
= *(void **)&clone_cb
;
2005 void *temp_function
= NULL
;
2007 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
2008 memcached_return_t rc
;
2009 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2010 test_true(temp_function
== clone_cb_ptr
);
2011 test_compare(MEMCACHED_SUCCESS
, rc
);
2014 /* Test Cleanup Callback */
2016 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2017 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2018 void *temp_function
= NULL
;
2019 memcached_return_t rc
;
2021 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2022 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2023 test_true(temp_function
== cleanup_cb_ptr
);
2026 return TEST_SUCCESS
;
2029 /* We don't test the behavior itself, we test the switches */
2030 static test_return_t
behavior_test(memcached_st
*memc
)
2032 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2033 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2035 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2036 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2038 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2039 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2041 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2042 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2044 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2045 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2047 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2048 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2050 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2051 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2053 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2055 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2057 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2058 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2059 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2061 return TEST_SUCCESS
;
2064 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2066 test_compare(MEMCACHED_DEPRECATED
,
2067 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2069 // Platform dependent
2071 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2075 return TEST_SUCCESS
;
2079 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2081 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2082 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2084 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2086 if (memcached_success(rc
))
2095 return TEST_SUCCESS
;
2099 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2101 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2102 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2104 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2106 if (memcached_success(rc
))
2115 return TEST_SUCCESS
;
2118 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, memcached_return_t
& rc
)
2122 memcached_result_st
* result
= NULL
;
2123 while ((result
= memcached_fetch_result(memc
, result
, &rc
)))
2125 test_compare(MEMCACHED_SUCCESS
, rc
);
2128 memcached_result_free(result
);
2130 return TEST_SUCCESS
;
2133 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
)
2135 memcached_return_t rc
;
2136 return fetch_all_results(memc
, keys_returned
, rc
);
2139 /* Test case provided by Cal Haldenbrand */
2140 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2141 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2142 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2144 /* We just keep looking at the same values over and over */
2147 test_compare(MEMCACHED_SUCCESS
,
2148 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2149 test_compare(MEMCACHED_SUCCESS
,
2150 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2154 unsigned long long total
= 0;
2155 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2157 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2158 char randomstuff
[6 * 1024];
2159 memset(randomstuff
, 0, 6 * 1024);
2160 test_true(size
< 6 * 1024); /* Being safe here */
2162 for (uint32_t j
= 0 ; j
< size
;j
++)
2164 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2168 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2169 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2170 test_compare(MEMCACHED_SUCCESS
,
2171 memcached_set(memc
, key
, key_length
,
2172 randomstuff
, strlen(randomstuff
),
2173 time_t(0), HALDENBRAND_FLAG_KEY
));
2175 test_true(total
> HALDENBRAND_KEY_COUNT
);
2177 return TEST_SUCCESS
;
2180 /* Test case provided by Cal Haldenbrand */
2181 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2183 test_compare(MEMCACHED_SUCCESS
,
2184 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2186 test_compare(MEMCACHED_SUCCESS
,
2187 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2190 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576));
2191 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576));
2192 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2193 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2195 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2198 size_t total_value_length
= 0;
2199 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2204 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2205 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2207 memcached_return_t rc
;
2208 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2209 if (memcached_failed(rc
))
2211 if (rc
== MEMCACHED_NOTFOUND
)
2222 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2225 total_value_length
+= val_len
;
2230 return TEST_SUCCESS
;
2233 /* Do a large mget() over all the keys we think exist */
2234 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2236 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2237 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2240 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576);
2241 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576);
2242 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2243 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2246 std::vector
<size_t> key_lengths
;
2247 key_lengths
.resize(HALDENBRAND_KEY_COUNT
);
2248 std::vector
<char *> keys
;
2249 keys
.resize(key_lengths
.size());
2250 for (uint32_t x
= 0; x
< key_lengths
.size(); x
++)
2252 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2253 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2254 test_true(key_length
> 0 and key_length
< MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1);
2255 keys
[x
]= strdup(key
);
2256 key_lengths
[x
]= key_length
;
2259 test_compare(MEMCACHED_SUCCESS
,
2260 memcached_mget(memc
, &keys
[0], &key_lengths
[0], key_lengths
.size()));
2262 unsigned int keys_returned
;
2263 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
));
2264 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2266 for (std::vector
<char *>::iterator iter
= keys
.begin();
2273 return TEST_SUCCESS
;
2276 /* Make sure we behave properly if server list has no values */
2277 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2279 const char *keys
[]= {"fudge", "son", "food"};
2280 size_t key_length
[]= {5, 3, 4};
2282 /* Here we free everything before running a bunch of mget tests */
2283 memcached_servers_reset(memc
);
2286 /* We need to empty the server before continueing test */
2287 test_compare(MEMCACHED_NO_SERVERS
,
2288 memcached_flush(memc
, 0));
2290 test_compare(MEMCACHED_NO_SERVERS
,
2291 memcached_mget(memc
, keys
, key_length
, 3));
2294 unsigned int keys_returned
;
2295 memcached_return_t rc
;
2296 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2297 test_compare(MEMCACHED_NOTFOUND
, rc
);
2298 test_zero(keys_returned
);
2301 for (uint32_t x
= 0; x
< 3; x
++)
2303 test_compare(MEMCACHED_NO_SERVERS
,
2304 memcached_set(memc
, keys
[x
], key_length
[x
],
2305 keys
[x
], key_length
[x
],
2306 (time_t)50, (uint32_t)9));
2309 test_compare(MEMCACHED_NO_SERVERS
,
2310 memcached_mget(memc
, keys
, key_length
, 3));
2314 char return_key
[MEMCACHED_MAX_KEY
];
2315 memcached_return_t rc
;
2316 size_t return_key_length
;
2317 size_t return_value_length
;
2320 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2321 &return_value_length
, &flags
, &rc
)))
2323 test_true(return_value
);
2324 test_compare(MEMCACHED_SUCCESS
, rc
);
2325 test_true(return_key_length
== return_value_length
);
2326 test_memcmp(return_value
, return_key
, return_value_length
);
2332 return TEST_SUCCESS
;
2335 #define VALUE_SIZE_BUG5 1048064
2336 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2338 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2339 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2341 size_t value_length
;
2343 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2345 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2347 insert_data
[x
]= (signed char)rand();
2350 test_compare(MEMCACHED_SUCCESS
,
2351 memcached_flush(memc
, 0));
2353 memcached_return_t rc
;
2354 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2355 test_compare(MEMCACHED_SUCCESS
,
2356 memcached_mget(memc
, keys
, key_length
, 4));
2359 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2360 test_compare(MEMCACHED_NOTFOUND
, rc
);
2363 for (uint32_t x
= 0; x
< 4; x
++)
2365 test_compare(MEMCACHED_SUCCESS
,
2366 memcached_set(memc
, keys
[x
], key_length
[x
],
2367 insert_data
, VALUE_SIZE_BUG5
,
2368 (time_t)0, (uint32_t)0));
2371 for (uint32_t x
= 0; x
< 10; x
++)
2373 value
= memcached_get(memc
, keys
[0], key_length
[0],
2374 &value_length
, &flags
, &rc
);
2375 test_compare(rc
, MEMCACHED_SUCCESS
);
2379 test_compare(MEMCACHED_SUCCESS
,
2380 memcached_mget(memc
, keys
, key_length
, 4));
2382 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2383 test_compare(4U, count
);
2385 delete [] insert_data
;
2387 return TEST_SUCCESS
;
2390 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2392 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2393 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2394 char return_key
[MEMCACHED_MAX_KEY
];
2395 size_t return_key_length
;
2397 size_t value_length
;
2399 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2401 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2403 insert_data
[x
]= (signed char)rand();
2406 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2408 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2410 // We will now confirm that memcached_mget() returns success, but we will
2411 // then check to make sure that no actual keys are returned.
2412 test_compare(MEMCACHED_SUCCESS
,
2413 memcached_mget(memc
, keys
, key_length
, 4));
2415 memcached_return_t rc
;
2417 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2418 &value_length
, &flags
, &rc
)))
2423 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2425 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2427 test_compare(MEMCACHED_SUCCESS
,
2428 memcached_set(memc
, keys
[x
], key_length
[x
],
2429 insert_data
, VALUE_SIZE_BUG5
,
2430 (time_t)0, (uint32_t)0));
2432 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2434 for (uint32_t x
= 0; x
< 2; x
++)
2436 value
= memcached_get(memc
, keys
[0], key_length
[0],
2437 &value_length
, &flags
, &rc
);
2441 test_compare(MEMCACHED_SUCCESS
,
2442 memcached_mget(memc
, keys
, key_length
, 4));
2443 /* We test for purge of partial complete fetches */
2444 for (count
= 3; count
; count
--)
2446 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2447 &value_length
, &flags
, &rc
);
2448 test_compare(MEMCACHED_SUCCESS
, rc
);
2449 test_memcmp(value
, insert_data
, value_length
);
2450 test_true(value_length
);
2454 delete [] insert_data
;
2456 return TEST_SUCCESS
;
2459 static test_return_t
user_supplied_bug8(memcached_st
*)
2461 memcached_return_t rc
;
2463 memcached_st
*memc_clone
;
2465 memcached_server_st
*servers
;
2466 const char *server_list
= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
2468 servers
= memcached_servers_parse(server_list
);
2471 mine
= memcached_create(NULL
);
2472 rc
= memcached_server_push(mine
, servers
);
2473 test_compare(MEMCACHED_SUCCESS
, rc
);
2474 memcached_server_list_free(servers
);
2477 memc_clone
= memcached_clone(NULL
, mine
);
2479 memcached_quit(mine
);
2480 memcached_quit(memc_clone
);
2483 memcached_free(mine
);
2484 memcached_free(memc_clone
);
2486 return TEST_SUCCESS
;
2489 /* Test flag store/retrieve */
2490 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2492 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2493 test_true(insert_data
);
2495 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2497 insert_data
[x
]= (signed char)rand();
2500 memcached_flush(memc
, 0);
2502 const char *keys
= "036790384900";
2503 size_t key_length
= strlen(keys
);
2504 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2505 insert_data
, VALUE_SIZE_BUG5
,
2507 memcached_last_error_message(memc
));
2509 memcached_return_t rc
;
2510 size_t value_length
;
2512 char *value
= memcached_get(memc
, keys
, key_length
,
2513 &value_length
, &flags
, &rc
);
2514 test_compare(245U, flags
);
2518 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2520 char return_key
[MEMCACHED_MAX_KEY
];
2521 size_t return_key_length
;
2523 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2524 &value_length
, &flags
, &rc
);
2525 test_compare(uint32_t(245), flags
);
2528 delete [] insert_data
;
2531 return TEST_SUCCESS
;
2534 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2536 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2537 size_t key_length
[3];
2541 char return_key
[MEMCACHED_MAX_KEY
];
2542 size_t return_key_length
;
2544 size_t return_value_length
;
2547 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2548 key_length
[1]= strlen("fudge&*@#");
2549 key_length
[2]= strlen("for^#@&$not");
2552 for (unsigned int x
= 0; x
< 3; x
++)
2554 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2555 keys
[x
], key_length
[x
],
2556 (time_t)50, (uint32_t)9);
2557 test_compare(MEMCACHED_SUCCESS
, rc
);
2560 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2561 test_compare(MEMCACHED_SUCCESS
, rc
);
2563 /* We need to empty the server before continueing test */
2564 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2565 &return_value_length
, &flags
, &rc
)) != NULL
)
2567 test_true(return_value
);
2571 test_compare(3U, count
);
2573 return TEST_SUCCESS
;
2576 /* We are testing with aggressive timeout to get failures */
2577 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2579 size_t value_length
= 512;
2580 unsigned int set
= 1;
2581 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2583 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2584 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2585 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2587 std::vector
<char> value
;
2588 value
.reserve(value_length
);
2589 for (uint32_t x
= 0; x
< value_length
; x
++)
2591 value
.push_back(char(x
% 127));
2594 for (unsigned int x
= 1; x
<= 100000; ++x
)
2596 memcached_return_t rc
= memcached_set(mclone
,
2597 test_literal_param("foo"),
2598 &value
[0], value
.size(),
2601 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2602 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2603 memcached_strerror(NULL
, rc
));
2605 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2611 memcached_free(mclone
);
2613 return TEST_SUCCESS
;
2617 We are looking failures in the async protocol
2619 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2621 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2623 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2624 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2625 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2627 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2630 std::vector
<char> value
;
2632 for (unsigned int x
= 0; x
< 512; x
++)
2634 value
.push_back(char(x
% 127));
2637 for (unsigned int x
= 1; x
<= 100000; ++x
)
2639 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2643 memcached_free(mclone
);
2645 return TEST_SUCCESS
;
2649 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2651 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2653 memcached_return_t rc
;
2655 size_t value_length
;
2657 uint64_t number_value
;
2659 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2660 &value_length
, &flags
, &rc
);
2662 test_compare(MEMCACHED_NOTFOUND
, rc
);
2664 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2667 /* The binary protocol will set the key if it doesn't exist */
2668 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2670 test_compare(MEMCACHED_SUCCESS
, rc
);
2674 test_compare(MEMCACHED_NOTFOUND
, rc
);
2677 test_compare(MEMCACHED_SUCCESS
,
2678 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2680 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2684 test_compare(MEMCACHED_SUCCESS
,
2685 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2686 test_compare(2UL, number_value
);
2688 return TEST_SUCCESS
;
2692 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2693 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2695 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2697 char key
[] = "key34567890";
2698 memcached_return_t rc
;
2699 size_t overflowSize
;
2701 char commandFirst
[]= "set key34567890 0 0 ";
2702 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2703 size_t commandLength
;
2706 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2708 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2710 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2712 char *overflow
= new (std::nothrow
) char[testSize
];
2713 test_true(overflow
);
2715 memset(overflow
, 'x', testSize
);
2716 rc
= memcached_set(memc
, key
, strlen(key
),
2717 overflow
, testSize
, 0, 0);
2718 test_compare(MEMCACHED_SUCCESS
, rc
);
2722 return TEST_SUCCESS
;
2727 Test values of many different sizes
2728 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2729 set key34567890 0 0 8169 \r\n
2730 is sent followed by buffer of size 8169, followed by 8169
2732 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2734 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2736 std::vector
<char> value
;
2737 value
.reserve(18000);
2738 for (size_t x
= 0; x
< 18000; x
++)
2740 value
.push_back((char) (x
% 127));
2743 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2745 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2746 &value
[0], current_length
,
2747 (time_t)0, (uint32_t)0);
2748 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2750 size_t string_length
;
2752 char *string
= memcached_get(memc
, test_literal_param("foo"),
2753 &string_length
, &flags
, &rc
);
2755 test_compare(MEMCACHED_SUCCESS
, rc
);
2756 test_compare(string_length
, current_length
);
2757 test_memcmp(string
, &value
[0], string_length
);
2762 return TEST_SUCCESS
;
2766 Look for zero length value problems
2768 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2770 for (uint32_t x
= 0; x
< 2; x
++)
2772 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2774 (time_t)0, (uint32_t)0);
2776 test_compare(MEMCACHED_SUCCESS
, rc
);
2780 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2781 &length
, &flags
, &rc
);
2783 test_compare(MEMCACHED_SUCCESS
, rc
);
2788 value
= memcached_get(memc
, test_literal_param("mykey"),
2789 &length
, &flags
, &rc
);
2791 test_compare(MEMCACHED_SUCCESS
, rc
);
2792 test_true(value
== NULL
);
2797 return TEST_SUCCESS
;
2800 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2801 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2803 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2805 (time_t)0, UINT32_MAX
),
2806 memcached_last_error_message(memc
));
2811 memcached_return_t rc
;
2812 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2813 &length
, &flags
, &rc
);
2815 test_compare(MEMCACHED_SUCCESS
, rc
);
2818 test_compare(flags
, UINT32_MAX
);
2820 return TEST_SUCCESS
;
2823 #if !defined(__sun) && !defined(__OpenBSD__)
2824 /* Check the validity of chinese key*/
2825 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2827 const char *key
= "豆瓣";
2828 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2829 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2830 value
, strlen(value
),
2833 test_compare(MEMCACHED_SUCCESS
, rc
);
2837 char *value2
= memcached_get(memc
, key
, strlen(key
),
2838 &length
, &flags
, &rc
);
2840 test_true(length
==strlen(value
));
2841 test_compare(MEMCACHED_SUCCESS
, rc
);
2842 test_memcmp(value
, value2
, length
);
2845 return TEST_SUCCESS
;
2853 static test_return_t
user_supplied_bug19(memcached_st
*)
2855 memcached_return_t res
;
2857 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2859 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2862 memcached_free(memc
);
2864 return TEST_SUCCESS
;
2867 /* CAS test from Andei */
2868 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2870 const char *key
= "abc";
2871 size_t key_len
= strlen("abc");
2873 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2875 test_compare(MEMCACHED_SUCCESS
,
2877 test_literal_param("abc"),
2878 test_literal_param("foobar"),
2879 (time_t)0, (uint32_t)0));
2881 test_compare(MEMCACHED_SUCCESS
,
2882 memcached_mget(memc
, &key
, &key_len
, 1));
2884 memcached_result_st result_obj
;
2885 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2888 memcached_result_create(memc
, &result_obj
);
2889 memcached_return_t status
;
2890 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2893 test_compare(MEMCACHED_SUCCESS
, status
);
2895 memcached_result_free(result
);
2897 return TEST_SUCCESS
;
2900 /* Large mget() of missing keys with binary proto
2902 * If many binary quiet commands (such as getq's in an mget) fill the output
2903 * buffer and the server chooses not to respond, memcached_flush hangs. See
2904 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2907 /* sighandler_t function that always asserts false */
2908 static void fail(int)
2914 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2919 return TEST_SKIPPED
;
2921 void (*oldalarm
)(int);
2923 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2924 test_true(memc_clone
);
2926 /* only binproto uses getq for mget */
2927 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2929 /* empty the cache to ensure misses (hence non-responses) */
2930 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2932 std::vector
<size_t> key_lengths
;
2933 key_lengths
.resize(key_count
);
2934 std::vector
<char *> keys
;
2935 keys
.resize(key_lengths
.size());
2936 for (unsigned int x
= 0; x
< key_lengths
.size(); x
++)
2938 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2939 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2940 test_true(key_length
> 0 and key_length
< MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1);
2941 keys
[x
]= strdup(key
);
2942 key_lengths
[x
]= key_length
;
2945 oldalarm
= signal(SIGALRM
, fail
);
2948 test_compare_got(MEMCACHED_SUCCESS
,
2949 memcached_mget(memc_clone
, &keys
[0], &key_lengths
[0], key_count
), memcached_last_error_message(memc_clone
));
2952 signal(SIGALRM
, oldalarm
);
2954 memcached_return_t rc
;
2956 char return_key
[MEMCACHED_MAX_KEY
];
2957 size_t return_key_length
;
2959 size_t return_value_length
;
2960 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2961 &return_value_length
, &flags
, &rc
)))
2963 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2965 test_compare(MEMCACHED_NOTFOUND
, rc
);
2966 test_zero(return_value_length
);
2967 test_zero(return_key_length
);
2968 test_false(return_key
[0]);
2969 test_false(return_value
);
2971 for (std::vector
<char *>::iterator iter
= keys
.begin();
2978 memcached_free(memc_clone
);
2980 return TEST_SUCCESS
;
2984 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
2986 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2988 /* should work as of r580 */
2989 test_compare(TEST_SUCCESS
,
2990 _user_supplied_bug21(memc
, 10));
2992 /* should fail as of r580 */
2993 test_compare(TEST_SUCCESS
,
2994 _user_supplied_bug21(memc
, 1000));
2996 return TEST_SUCCESS
;
2999 static test_return_t
output_ketama_weighted_keys(memcached_st
*)
3001 memcached_st
*memc
= memcached_create(NULL
);
3005 test_compare(MEMCACHED_SUCCESS
,
3006 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
3008 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3009 test_compare(value
, uint64_t(1));
3011 test_compare(MEMCACHED_SUCCESS
,
3012 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3014 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3015 test_true(value
== MEMCACHED_HASH_MD5
);
3018 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3020 memcached_server_st
*server_pool
;
3021 server_pool
= memcached_servers_parse("10.0.1.1:11211,10.0.1.2:11211,10.0.1.3:11211,10.0.1.4:11211,10.0.1.5:11211,10.0.1.6:11211,10.0.1.7:11211,10.0.1.8:11211,192.168.1.1:11211,192.168.100.1:11211");
3022 memcached_server_push(memc
, server_pool
);
3024 // @todo this needs to be refactored to actually test something.
3027 if ((fp
= fopen("ketama_keys.txt", "w")))
3031 printf("cannot write to file ketama_keys.txt");
3032 return TEST_FAILURE
;
3035 for (int x
= 0; x
< 10000; x
++)
3038 snprintf(key
, sizeof(key
), "%d", x
);
3040 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3041 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3042 in_port_t port
= memc
->hosts
[server_idx
].port
;
3043 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3044 memcached_server_instance_st instance
=
3045 memcached_server_instance_by_position(memc
, host_index
);
3049 memcached_server_list_free(server_pool
);
3050 memcached_free(memc
);
3052 return TEST_SUCCESS
;
3056 static test_return_t
result_static(memcached_st
*memc
)
3058 memcached_result_st result
;
3059 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3060 test_false(result
.options
.is_allocated
);
3061 test_true(memcached_is_initialized(&result
));
3062 test_true(result_ptr
);
3063 test_true(result_ptr
== &result
);
3065 memcached_result_free(&result
);
3067 test_false(result
.options
.is_allocated
);
3068 test_false(memcached_is_initialized(&result
));
3070 return TEST_SUCCESS
;
3073 static test_return_t
result_alloc(memcached_st
*memc
)
3075 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3076 test_true(result_ptr
);
3077 test_true(result_ptr
->options
.is_allocated
);
3078 test_true(memcached_is_initialized(result_ptr
));
3079 memcached_result_free(result_ptr
);
3081 return TEST_SUCCESS
;
3084 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3087 pairs_free(global_pairs
);
3089 return TEST_SUCCESS
;
3092 static test_return_t
generate_pairs(memcached_st
*)
3094 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3095 global_count
= GLOBAL_COUNT
;
3097 for (size_t x
= 0; x
< global_count
; x
++)
3099 global_keys
[x
]= global_pairs
[x
].key
;
3100 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3103 return TEST_SUCCESS
;
3106 static test_return_t
generate_large_pairs(memcached_st
*)
3108 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3109 global_count
= GLOBAL2_COUNT
;
3111 for (size_t x
= 0; x
< global_count
; x
++)
3113 global_keys
[x
]= global_pairs
[x
].key
;
3114 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3117 return TEST_SUCCESS
;
3120 static test_return_t
generate_data(memcached_st
*memc
)
3122 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3124 test_compare_warn_hint(global_count
, check_execute
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3126 return TEST_SUCCESS
;
3129 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3131 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3133 test_compare(check_execute
, global_count
);
3135 // @todo hosts used size stats
3136 memcached_return_t rc
;
3137 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3140 for (uint32_t host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3142 /* This test was changes so that "make test" would work properlly */
3145 memcached_server_instance_st instance
=
3146 memcached_server_instance_by_position(memc
, host_index
);
3148 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3150 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3153 memcached_stat_free(NULL
, stat_p
);
3155 return TEST_SUCCESS
;
3157 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3159 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3160 generate_data(memc
);
3162 return TEST_SUCCESS
;
3165 static test_return_t
get_read_count(memcached_st
*memc
)
3167 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3168 test_true(memc_clone
);
3170 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3174 size_t return_value_length
;
3178 for (size_t x
= count
= 0; x
< global_count
; x
++)
3180 memcached_return_t rc
;
3181 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3182 &return_value_length
, &flags
, &rc
);
3183 if (rc
== MEMCACHED_SUCCESS
)
3194 memcached_free(memc_clone
);
3196 return TEST_SUCCESS
;
3199 static test_return_t
get_read(memcached_st
*memc
)
3201 size_t keys_returned
= 0;
3202 for (size_t x
= 0; x
< global_count
; x
++)
3204 size_t return_value_length
;
3206 memcached_return_t rc
;
3207 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3208 &return_value_length
, &flags
, &rc
);
3210 test_true(return_value);
3211 test_compare(MEMCACHED_SUCCESS, rc);
3213 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3219 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3221 return TEST_SUCCESS
;
3224 static test_return_t
mget_read(memcached_st
*memc
)
3227 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3229 test_compare(MEMCACHED_SUCCESS
,
3230 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3232 // Go fetch the keys and test to see if all of them were returned
3234 unsigned int keys_returned
;
3235 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
));
3236 test_true(keys_returned
> 0);
3237 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3240 return TEST_SUCCESS
;
3243 static test_return_t
mget_read_result(memcached_st
*memc
)
3246 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3248 test_compare(MEMCACHED_SUCCESS
,
3249 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3251 /* Turn this into a help function */
3253 memcached_result_st results_obj
;
3254 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3257 memcached_return_t rc
;
3258 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3260 if (rc
== MEMCACHED_IN_PROGRESS
)
3266 test_compare(MEMCACHED_SUCCESS
, rc
);
3268 test_compare(MEMCACHED_END
, rc
);
3270 memcached_result_free(&results_obj
);
3273 return TEST_SUCCESS
;
3276 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3279 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3281 test_compare(MEMCACHED_SUCCESS
,
3282 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3284 memcached_result_st
*results
= NULL
;
3285 memcached_return_t rc
;
3286 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3289 test_compare(MEMCACHED_SUCCESS
, rc
);
3291 test_compare(MEMCACHED_END
, rc
);
3293 memcached_result_free(results
);
3296 return TEST_SUCCESS
;
3299 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3302 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3304 test_compare(MEMCACHED_SUCCESS
,
3305 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3307 // We will scan for just one key
3309 memcached_result_st results_obj
;
3310 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3312 memcached_return_t rc
;
3313 results
= memcached_fetch_result(memc
, results
, &rc
);
3315 test_compare(MEMCACHED_SUCCESS
, rc
);
3317 memcached_result_free(&results_obj
);
3320 // We already have a read happening, lets start up another one.
3321 test_compare(MEMCACHED_SUCCESS
,
3322 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3324 memcached_result_st results_obj
;
3325 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3327 test_false(memcached_is_allocated(results
));
3329 memcached_return_t rc
;
3330 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3333 test_compare(MEMCACHED_SUCCESS
, rc
);
3335 test_compare(MEMCACHED_END
, rc
);
3337 memcached_result_free(&results_obj
);
3340 return TEST_SUCCESS
;
3343 static test_return_t
mget_read_function(memcached_st
*memc
)
3345 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3347 test_compare(MEMCACHED_SUCCESS
,
3348 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3350 memcached_execute_fn callbacks
[]= { &callback_counter
};
3352 test_compare(MEMCACHED_SUCCESS
,
3353 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3355 return TEST_SUCCESS
;
3358 static test_return_t
delete_generate(memcached_st
*memc
)
3361 for (size_t x
= 0; x
< global_count
; x
++)
3363 if (memcached_success(memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0)))
3368 test_compare_warn_hint(global_count
, total
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3370 return TEST_SUCCESS
;
3373 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3375 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3378 for (size_t x
= 0; x
< global_count
; x
++)
3380 if (memcached_success(memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0)))
3385 test_compare_warn_hint(global_count
, total
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3387 return TEST_SUCCESS
;
3390 static test_return_t
add_host_test1(memcached_st
*memc
)
3392 memcached_return_t rc
;
3393 char servername
[]= "0.example.com";
3395 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3397 test_compare(1U, memcached_server_list_count(servers
));
3399 for (uint32_t x
= 2; x
< 20; x
++)
3401 char buffer
[SMALL_STRING_LEN
];
3403 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3404 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3406 test_compare(MEMCACHED_SUCCESS
, rc
);
3407 test_compare(x
, memcached_server_list_count(servers
));
3410 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3411 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3413 memcached_server_list_free(servers
);
3415 return TEST_SUCCESS
;
3418 static test_return_t
pre_nonblock(memcached_st
*memc
)
3420 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3422 return TEST_SUCCESS
;
3425 static test_return_t
pre_cork(memcached_st
*memc
)
3428 return TEST_SKIPPED
;
3431 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3432 return TEST_SUCCESS
;
3434 return TEST_SKIPPED
;
3437 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3440 return TEST_SKIPPED
;
3442 test_return_t test_rc
;
3443 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3446 return pre_nonblock(memc
);
3449 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3451 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3452 test_true(memc_clone
);
3454 // The memcached_version needs to be done on a clone, because the server
3455 // will not toggle protocol on an connection.
3456 memcached_version(memc_clone
);
3458 memcached_return_t rc
= MEMCACHED_FAILURE
;
3459 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3461 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3462 test_compare(MEMCACHED_SUCCESS
,
3463 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3464 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3468 memcached_free(memc_clone
);
3469 return TEST_SKIPPED
;
3472 memcached_free(memc_clone
);
3474 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3477 static test_return_t
pre_murmur(memcached_st
*memc
)
3479 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3480 return TEST_SUCCESS
;
3483 static test_return_t
pre_jenkins(memcached_st
*memc
)
3485 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3487 return TEST_SKIPPED
;
3491 static test_return_t
pre_md5(memcached_st
*memc
)
3493 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3495 return TEST_SUCCESS
;
3498 static test_return_t
pre_crc(memcached_st
*memc
)
3500 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3502 return TEST_SUCCESS
;
3505 static test_return_t
pre_hsieh(memcached_st
*memc
)
3507 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
));
3508 return TEST_SUCCESS
;
3511 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3513 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3515 return TEST_SUCCESS
;
3518 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3520 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
));
3522 return TEST_SUCCESS
;
3525 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3527 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3529 return TEST_SUCCESS
;
3532 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3534 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3536 return TEST_SUCCESS
;
3539 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3541 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3542 test_compare(MEMCACHED_SUCCESS
, rc
);
3544 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3545 test_compare(value
, uint64_t(1));
3547 return TEST_SUCCESS
;
3550 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3552 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3553 test_compare(MEMCACHED_SUCCESS
, rc
);
3555 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3556 test_compare(value
, uint64_t(1));
3558 test_compare(MEMCACHED_SUCCESS
,
3559 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3561 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3562 test_compare(MEMCACHED_HASH_MD5
, memcached_hash_t(value
));
3564 return TEST_SUCCESS
;
3567 static test_return_t
pre_replication(memcached_st
*memc
)
3569 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3572 * Make sure that we store the item on all servers
3573 * (master + replicas == number of servers)
3575 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3576 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3578 return TEST_SUCCESS
;
3582 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3584 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3586 return pre_nonblock(memc
);
3590 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3594 #ifdef HARD_MALLOC_TESTS
3595 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3603 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3607 #ifdef HARD_MALLOC_TESTS
3608 void *ret
= malloc(size
+ 8);
3611 ret
= (void*)((caddr_t
)ret
+ 8);
3614 void *ret
= malloc(size
);
3619 memset(ret
, 0xff, size
);
3626 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3628 #ifdef HARD_MALLOC_TESTS
3629 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3630 void *nmem
= realloc(real_ptr
, size
+ 8);
3635 ret
= (void*)((caddr_t
)nmem
+ 8);
3641 return realloc(mem
, size
);
3646 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3648 #ifdef HARD_MALLOC_TESTS
3649 void *mem
= my_malloc(ptr
, nelem
* size
);
3652 memset(mem
, 0, nelem
* size
);
3658 return calloc(nelem
, size
);
3662 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3664 memcached_return_t rc
;
3665 const char *key
= "mine";
3668 /* Make sure be default none exists */
3669 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3671 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3673 /* Test a clean set */
3674 test_compare(MEMCACHED_SUCCESS
,
3675 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3677 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3679 test_memcmp(value
, key
, 4);
3680 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3682 /* Test that we can turn it off */
3683 test_compare(MEMCACHED_SUCCESS
,
3684 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3686 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3688 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3690 /* Now setup for main test */
3691 test_compare(MEMCACHED_SUCCESS
,
3692 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3694 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3696 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3697 test_memcmp(value
, key
, 4);
3699 /* Set to Zero, and then Set to something too large */
3702 memset(long_key
, 0, 255);
3704 test_compare(MEMCACHED_SUCCESS
,
3705 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3707 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3709 test_compare(MEMCACHED_SUCCESS
, rc
);
3711 /* Test a long key for failure */
3712 /* TODO, extend test to determine based on setting, what result should be */
3713 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3714 test_compare(MEMCACHED_SUCCESS
,
3715 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3717 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3718 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3719 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3720 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3722 /* Test for a bad prefix, but with a short key */
3723 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3724 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3726 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3727 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3730 return TEST_SUCCESS
;
3733 static test_return_t
set_namespace(memcached_st
*memc
)
3735 memcached_return_t rc
;
3736 const char *key
= "mine";
3739 // Make sure we default to a null namespace
3740 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3742 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3744 /* Test a clean set */
3745 test_compare(MEMCACHED_SUCCESS
,
3746 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3748 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3750 test_memcmp(value
, key
, 4);
3751 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3753 return TEST_SUCCESS
;
3756 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3758 test_return_if(pre_binary(memc
));
3759 test_return_if(set_namespace(memc
));
3761 return TEST_SUCCESS
;
3764 #ifdef MEMCACHED_ENABLE_DEPRECATED
3765 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3767 void *test_ptr
= NULL
;
3770 memcached_malloc_fn malloc_cb
=
3771 (memcached_malloc_fn
)my_malloc
;
3772 cb_ptr
= *(void **)&malloc_cb
;
3773 memcached_return_t rc
;
3775 test_compare(MEMCACHED_SUCCESS
,
3776 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3777 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3778 test_compare(MEMCACHED_SUCCESS
, rc
);
3779 test_true(test_ptr
== cb_ptr
);
3783 memcached_realloc_fn realloc_cb
=
3784 (memcached_realloc_fn
)my_realloc
;
3785 cb_ptr
= *(void **)&realloc_cb
;
3786 memcached_return_t rc
;
3788 test_compare(MEMCACHED_SUCCESS
,
3789 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3790 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3791 test_compare(MEMCACHED_SUCCESS
, rc
);
3792 test_true(test_ptr
== cb_ptr
);
3796 memcached_free_fn free_cb
=
3797 (memcached_free_fn
)my_free
;
3798 cb_ptr
= *(void **)&free_cb
;
3799 memcached_return_t rc
;
3801 test_compare(MEMCACHED_SUCCESS
,
3802 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3803 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3804 test_compare(MEMCACHED_SUCCESS
, rc
);
3805 test_true(test_ptr
== cb_ptr
);
3808 return TEST_SUCCESS
;
3813 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3815 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3816 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3817 my_realloc
, my_calloc
, NULL
));
3819 test_compare(MEMCACHED_SUCCESS
,
3820 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3821 my_realloc
, my_calloc
, NULL
));
3823 memcached_malloc_fn mem_malloc
;
3824 memcached_free_fn mem_free
;
3825 memcached_realloc_fn mem_realloc
;
3826 memcached_calloc_fn mem_calloc
;
3827 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3828 &mem_realloc
, &mem_calloc
);
3830 test_true(mem_malloc
== my_malloc
);
3831 test_true(mem_realloc
== my_realloc
);
3832 test_true(mem_calloc
== my_calloc
);
3833 test_true(mem_free
== my_free
);
3835 return TEST_SUCCESS
;
3838 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3841 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3842 memcached_hash_t hash
;
3843 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3844 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3847 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3848 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3850 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3852 if (hash
!= MEMCACHED_HASH_CRC
)
3853 return TEST_SKIPPED
;
3855 return TEST_SUCCESS
;
3858 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3861 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3862 memcached_hash_t hash
;
3863 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3864 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3869 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3870 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3872 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3874 if (hash
!= MEMCACHED_HASH_HSIEH
)
3875 return TEST_SKIPPED
;
3878 return TEST_SUCCESS
;
3881 static test_return_t
enable_cas(memcached_st
*memc
)
3883 unsigned int set
= 1;
3885 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3887 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3889 return TEST_SUCCESS
;
3892 return TEST_SKIPPED
;
3895 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3897 memcached_version(memc
);
3899 memcached_server_instance_st instance
=
3900 memcached_server_instance_by_position(memc
, 0);
3902 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3903 or instance
->minor_version
> 2)
3905 return TEST_SUCCESS
;
3908 return TEST_SKIPPED
;
3911 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3915 memcached_servers_reset(memc
);
3916 const char *socket_file
= default_socket();
3918 test_skip(0, stat(socket_file
, &buf
));
3920 test_compare(MEMCACHED_SUCCESS
,
3921 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
3923 return TEST_SUCCESS
;
3926 static test_return_t
pre_nodelay(memcached_st
*memc
)
3928 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3929 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3931 return TEST_SUCCESS
;
3934 static test_return_t
pre_settimer(memcached_st
*memc
)
3936 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3937 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3939 return TEST_SUCCESS
;
3942 static test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3944 const uint64_t timeout
= 100; // Not using, just checking that it sets
3946 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3948 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3950 return TEST_SUCCESS
;
3953 static test_return_t
noreply_test(memcached_st
*memc
)
3955 test_compare(MEMCACHED_SUCCESS
,
3956 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3957 test_compare(MEMCACHED_SUCCESS
,
3958 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3959 test_compare(MEMCACHED_SUCCESS
,
3960 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3961 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3962 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3963 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3965 memcached_return_t ret
;
3966 for (int count
= 0; count
< 5; ++count
)
3968 for (size_t x
= 0; x
< 100; ++x
)
3970 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3971 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3972 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3974 size_t len
= (size_t)check_length
;
3979 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3982 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3985 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3988 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3991 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3997 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, ret
));
4001 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4002 ** API and is _ONLY_ done this way to verify that the library works the
4003 ** way it is supposed to do!!!!
4006 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4008 memcached_server_instance_st instance
=
4009 memcached_server_instance_by_position(memc
, x
);
4010 no_msg
+=(int)(instance
->cursor_active
);
4013 test_true(no_msg
== 0);
4014 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4017 ** Now validate that all items was set properly!
4019 for (size_t x
= 0; x
< 100; ++x
)
4023 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4025 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4027 size_t len
= (size_t)check_length
;
4030 char* value
=memcached_get(memc
, key
, strlen(key
),
4031 &length
, &flags
, &ret
);
4032 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
4035 case 0: /* FALLTHROUGH */
4036 case 1: /* FALLTHROUGH */
4038 test_true(strncmp(value
, key
, len
) == 0);
4039 test_true(len
== length
);
4042 test_true(length
== len
* 2);
4045 test_true(length
== len
* 3);
4055 /* Try setting an illegal cas value (should not return an error to
4056 * the caller (because we don't expect a return message from the server)
4058 const char* keys
[]= {"0"};
4059 size_t lengths
[]= {1};
4062 memcached_result_st results_obj
;
4063 memcached_result_st
*results
;
4064 test_compare(MEMCACHED_SUCCESS
,
4065 memcached_mget(memc
, keys
, lengths
, 1));
4067 results
= memcached_result_create(memc
, &results_obj
);
4069 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4071 test_compare(MEMCACHED_SUCCESS
, ret
);
4072 uint64_t cas
= memcached_result_cas(results
);
4073 memcached_result_free(&results_obj
);
4075 test_compare(MEMCACHED_SUCCESS
,
4076 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4079 * The item will have a new cas value, so try to set it again with the old
4080 * value. This should fail!
4082 test_compare(MEMCACHED_SUCCESS
,
4083 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4084 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4085 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4086 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4089 return TEST_SUCCESS
;
4092 static test_return_t
analyzer_test(memcached_st
*memc
)
4094 memcached_analysis_st
*report
;
4095 memcached_return_t rc
;
4097 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4098 test_compare(MEMCACHED_SUCCESS
, rc
);
4099 test_true(memc_stat
);
4101 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4102 test_compare(MEMCACHED_SUCCESS
, rc
);
4106 memcached_stat_free(NULL
, memc_stat
);
4108 return TEST_SUCCESS
;
4111 static test_return_t
util_version_test(memcached_st
*memc
)
4113 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
4114 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
4116 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4118 // We expect failure
4121 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4122 fprintf(stderr
, "\nDumping Server Information\n\n");
4123 memcached_server_fn callbacks
[1];
4125 callbacks
[0]= dump_server_information
;
4126 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4127 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4129 test_true(if_successful
== false);
4131 memcached_server_instance_st instance
=
4132 memcached_server_instance_by_position(memc
, 0);
4134 memcached_version(memc
);
4136 // We only use one binary when we test, so this should be just fine.
4137 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4138 test_true(if_successful
== true);
4140 if (instance
->micro_version
> 0)
4142 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4144 else if (instance
->minor_version
> 0)
4146 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4148 else if (instance
->major_version
> 0)
4150 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4153 test_true(if_successful
== true);
4155 if (instance
->micro_version
> 0)
4157 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4159 else if (instance
->minor_version
> 0)
4161 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4163 else if (instance
->major_version
> 0)
4165 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4168 test_true(if_successful
== false);
4170 return TEST_SUCCESS
;
4173 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4175 memcached_return_t rc
;
4176 memcached_server_instance_st instance
=
4177 memcached_server_instance_by_position(memc
, 0);
4179 // Test both the version that returns a code, and the one that does not.
4180 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4181 memcached_server_port(instance
) -1, NULL
) == -1);
4183 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4184 memcached_server_port(instance
) -1, &rc
) == -1);
4185 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4187 return TEST_SUCCESS
;
4191 static test_return_t
getpid_test(memcached_st
*memc
)
4193 memcached_return_t rc
;
4194 memcached_server_instance_st instance
=
4195 memcached_server_instance_by_position(memc
, 0);
4197 // Test both the version that returns a code, and the one that does not.
4198 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4199 memcached_server_port(instance
), NULL
) > -1);
4201 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4202 memcached_server_port(instance
), &rc
) > -1);
4203 test_compare(MEMCACHED_SUCCESS
, rc
);
4205 return TEST_SUCCESS
;
4208 static test_return_t
ping_test(memcached_st
*memc
)
4210 memcached_return_t rc
;
4211 memcached_server_instance_st instance
=
4212 memcached_server_instance_by_position(memc
, 0);
4214 // Test both the version that returns a code, and the one that does not.
4215 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4216 memcached_server_port(instance
), NULL
));
4218 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4219 memcached_server_port(instance
), &rc
));
4221 test_compare(MEMCACHED_SUCCESS
, rc
);
4223 return TEST_SUCCESS
;
4228 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4232 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4233 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4234 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4235 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4236 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4237 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4238 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4239 #ifdef HAVE_HSIEH_HASH
4240 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4242 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4243 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4244 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4246 return TEST_SUCCESS
;
4250 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4252 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4254 test_compare(MEMCACHED_SUCCESS
,
4255 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4256 (uint64_t)MEMCACHED_HASH_HSIEH
));
4258 return TEST_SUCCESS
;
4261 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4263 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4265 test_compare(MEMCACHED_SUCCESS
,
4266 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
4268 return TEST_SUCCESS
;
4271 static test_return_t
one_at_a_time_run (memcached_st
*)
4276 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4278 test_compare(one_at_a_time_values
[x
],
4279 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
4282 return TEST_SUCCESS
;
4285 static test_return_t
md5_run (memcached_st
*)
4290 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4292 test_compare(md5_values
[x
],
4293 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
4296 return TEST_SUCCESS
;
4299 static test_return_t
crc_run (memcached_st
*)
4304 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4306 test_compare(crc_values
[x
],
4307 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
4310 return TEST_SUCCESS
;
4313 static test_return_t
fnv1_64_run (memcached_st
*)
4315 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
4320 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4322 test_compare(fnv1_64_values
[x
],
4323 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
4326 return TEST_SUCCESS
;
4329 static test_return_t
fnv1a_64_run (memcached_st
*)
4331 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
4336 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4338 test_compare(fnv1a_64_values
[x
],
4339 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
4342 return TEST_SUCCESS
;
4345 static test_return_t
fnv1_32_run (memcached_st
*)
4350 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4352 test_compare(fnv1_32_values
[x
],
4353 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
4356 return TEST_SUCCESS
;
4359 static test_return_t
fnv1a_32_run (memcached_st
*)
4364 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4366 test_compare(fnv1a_32_values
[x
],
4367 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
4370 return TEST_SUCCESS
;
4373 static test_return_t
hsieh_run (memcached_st
*)
4375 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4380 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4382 test_compare(hsieh_values
[x
],
4383 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
4386 return TEST_SUCCESS
;
4389 static test_return_t
murmur_run (memcached_st
*)
4391 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4393 #ifdef WORDS_BIGENDIAN
4394 (void)murmur_values
;
4395 return TEST_SKIPPED
;
4400 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4402 test_compare(murmur_values
[x
],
4403 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
4406 return TEST_SUCCESS
;
4410 static test_return_t
jenkins_run (memcached_st
*)
4415 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4417 test_compare(jenkins_values
[x
],
4418 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
4421 return TEST_SUCCESS
;
4424 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
4426 return libhashkit_md5(string
, string_length
);
4429 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
4431 return libhashkit_crc32(string
, string_length
);
4434 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4440 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
4442 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};
4443 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};
4445 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4447 hashkit_clone(&new_kit
, kit
);
4448 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4450 memcached_set_hashkit(memc
, &new_kit
);
4453 Verify Setting the hash.
4455 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4459 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4460 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4465 Now check memcached_st.
4467 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4471 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4472 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4475 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4477 memcached_set_hashkit(memc
, &new_kit
);
4480 Verify Setting the hash.
4482 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4486 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4487 test_true(crc_values
[x
] == hash_val
);
4490 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4494 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4495 test_compare(crc_hosts
[x
], hash_val
);
4498 memcached_free(memc
);
4500 return TEST_SUCCESS
;
4504 Test case adapted from John Gorman <johngorman2@gmail.com>
4506 We are testing the error condition when we connect to a server via memcached_get()
4507 but find that the server is not available.
4509 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4511 const char *key
= "MemcachedLives";
4514 memcached_return rc
;
4517 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4519 // See if memcached is reachable.
4520 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4524 test_true(memcached_failed(rc
));
4526 memcached_free(tl_memc_h
);
4528 return TEST_SUCCESS
;
4532 We connect to a server which exists, but search for a key that does not exist.
4534 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4536 const char *key
= "MemcachedKeyNotEXIST";
4539 memcached_return rc
;
4541 // See if memcached is reachable.
4542 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4546 test_compare(MEMCACHED_NOTFOUND
, rc
);
4548 return TEST_SUCCESS
;
4552 Test case adapted from John Gorman <johngorman2@gmail.com>
4554 We are testing the error condition when we connect to a server via memcached_get_by_key()
4555 but find that the server is not available.
4557 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4560 memcached_st
*tl_memc_h
;
4561 memcached_server_st
*servers
;
4563 const char *key
= "MemcachedLives";
4566 memcached_return rc
;
4570 tl_memc_h
= memcached_create(NULL
);
4571 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4572 memcached_server_push(tl_memc_h
, servers
);
4573 memcached_server_list_free(servers
);
4575 // See if memcached is reachable.
4576 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4580 test_true(memcached_failed(rc
));
4582 memcached_free(tl_memc_h
);
4584 return TEST_SUCCESS
;
4588 We connect to a server which exists, but search for a key that does not exist.
4590 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4592 const char *key
= "MemcachedKeyNotEXIST";
4595 memcached_return rc
;
4598 // See if memcached is reachable.
4599 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4603 test_compare(MEMCACHED_NOTFOUND
, rc
);
4605 return TEST_SUCCESS
;
4608 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4610 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4612 const char *key
= "regression_bug_434484";
4613 size_t keylen
= strlen(key
);
4615 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4616 test_compare(MEMCACHED_NOTSTORED
, ret
);
4618 size_t size
= 2048 * 1024;
4619 char *data
= (char*)calloc(1, size
);
4621 test_compare(MEMCACHED_E2BIG
,
4622 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4625 return TEST_SUCCESS
;
4628 static test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4630 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4632 memcached_return_t rc
;
4634 memcached_execute_fn callbacks
[]= { &callback_counter
};
4637 * I only want to hit only _one_ server so I know the number of requests I'm
4638 * sending in the pipleine to the server. Let's try to do a multiget of
4639 * 1024 (that should satisfy most users don't you think?). Future versions
4640 * will include a mget_execute function call if you need a higher number.
4642 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4644 const size_t max_keys
= 1024;
4645 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4646 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4648 for (size_t x
= 0; x
< max_keys
; ++x
)
4652 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4658 * Run two times.. the first time we should have 100% cache miss,
4659 * and the second time we should have 100% cache hits
4661 for (size_t y
= 0; y
< 2; y
++)
4663 test_compare(MEMCACHED_SUCCESS
,
4664 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4666 // One the first run we should get a NOT_FOUND, but on the second some data
4667 // should be returned.
4668 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4669 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4673 /* The first iteration should give me a 100% cache miss. verify that*/
4674 char blob
[1024]= { 0 };
4676 test_false(counter
);
4678 for (size_t x
= 0; x
< max_keys
; ++x
)
4680 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4681 blob
, sizeof(blob
), 0, 0);
4682 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4687 /* Verify that we received all of the key/value pairs */
4688 test_compare(counter
, max_keys
);
4692 /* Release allocated resources */
4693 for (size_t x
= 0; x
< max_keys
; ++x
)
4700 memcached_free(memc
);
4702 return TEST_SUCCESS
;
4705 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4707 memcached_return_t rc
;
4708 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4709 test_compare(MEMCACHED_SUCCESS
, rc
);
4711 return regression_bug_434843(memc
);
4714 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4716 memcached_return_t rc
;
4717 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4718 test_compare(MEMCACHED_SUCCESS
, rc
);
4720 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4721 test_compare(MEMCACHED_SUCCESS
, rc
);
4722 test_true(bytes_str
);
4723 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4725 test_compare(MEMCACHED_SUCCESS
, rc
);
4726 test_true(bytes_read_str
);
4728 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4729 "bytes_written", &rc
);
4730 test_compare(MEMCACHED_SUCCESS
, rc
);
4731 test_true(bytes_written_str
);
4733 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4734 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4735 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4737 test_true(bytes
!= bytes_read
);
4738 test_true(bytes
!= bytes_written
);
4740 /* Release allocated resources */
4742 free(bytes_read_str
);
4743 free(bytes_written_str
);
4744 memcached_stat_free(NULL
, memc_stat
);
4746 return TEST_SUCCESS
;
4750 * The test case isn't obvious so I should probably document why
4751 * it works the way it does. Bug 442914 was caused by a bug
4752 * in the logic in memcached_purge (it did not handle the case
4753 * where the number of bytes sent was equal to the watermark).
4754 * In this test case, create messages so that we hit that case
4755 * and then disable noreply mode and issue a new command to
4756 * verify that it isn't stuck. If we change the format for the
4757 * delete command or the watermarks, we need to update this
4760 static test_return_t
regression_bug_442914(memcached_st
*memc
)
4762 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4763 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4765 uint32_t number_of_hosts
= memcached_server_count(memc
);
4766 memc
->number_of_hosts
= 1;
4771 for (uint32_t x
= 0; x
< 250; ++x
)
4773 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4774 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4775 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4778 len
= snprintf(k
, sizeof(k
), "%037u", 251U);
4780 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4781 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4783 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4784 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
4786 memc
->number_of_hosts
= number_of_hosts
;
4788 return TEST_SUCCESS
;
4791 static test_return_t
regression_bug_447342(memcached_st
*memc
)
4793 memcached_server_instance_st instance_one
;
4794 memcached_server_instance_st instance_two
;
4796 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4797 return TEST_SKIPPED
;
4799 test_compare(MEMCACHED_SUCCESS
,
4800 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4802 const unsigned int max_keys
= 100;
4803 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4804 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4806 for (unsigned int x
= 0; x
< max_keys
; ++x
)
4810 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4813 test_compare(MEMCACHED_SUCCESS
,
4814 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
4818 ** We are using the quiet commands to store the replicas, so we need
4819 ** to ensure that all of them are processed before we can continue.
4820 ** In the test we go directly from storing the object to trying to
4821 ** receive the object from all of the different servers, so we
4822 ** could end up in a race condition (the memcached server hasn't yet
4823 ** processed the quiet command from the replication set when it process
4824 ** the request from the other client (created by the clone)). As a
4825 ** workaround for that we call memcached_quit to send the quit command
4826 ** to the server and wait for the response ;-) If you use the test code
4827 ** as an example for your own code, please note that you shouldn't need
4830 memcached_quit(memc
);
4832 /* Verify that all messages are stored, and we didn't stuff too much
4835 test_compare(MEMCACHED_SUCCESS
,
4836 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4838 unsigned int counter
= 0;
4839 memcached_execute_fn callbacks
[]= { &callback_counter
};
4840 test_compare(MEMCACHED_SUCCESS
,
4841 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4843 /* Verify that we received all of the key/value pairs */
4844 test_compare(counter
, max_keys
);
4846 memcached_quit(memc
);
4848 * Don't do the following in your code. I am abusing the internal details
4849 * within the library, and this is not a supported interface.
4850 * This is to verify correct behavior in the library. Fake that two servers
4853 instance_one
= memcached_server_instance_by_position(memc
, 0);
4854 instance_two
= memcached_server_instance_by_position(memc
, 2);
4855 in_port_t port0
= instance_one
->port
;
4856 in_port_t port2
= instance_two
->port
;
4858 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4859 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4861 test_compare(MEMCACHED_SUCCESS
,
4862 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4865 test_compare(MEMCACHED_SUCCESS
,
4866 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4867 test_compare(counter
, (unsigned int)max_keys
);
4869 /* restore the memc handle */
4870 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4871 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4873 memcached_quit(memc
);
4875 /* Remove half of the objects */
4876 for (size_t x
= 0; x
< max_keys
; ++x
)
4880 test_compare(MEMCACHED_SUCCESS
,
4881 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
4885 memcached_quit(memc
);
4886 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4887 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4889 /* now retry the command, this time we should have cache misses */
4890 test_compare(MEMCACHED_SUCCESS
,
4891 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4894 test_compare(MEMCACHED_SUCCESS
,
4895 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4896 test_compare(counter
, (unsigned int)(max_keys
>> 1));
4898 /* Release allocated resources */
4899 for (size_t x
= 0; x
< max_keys
; ++x
)
4906 /* restore the memc handle */
4907 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4908 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4910 return TEST_SUCCESS
;
4913 static test_return_t
regression_bug_463297(memcached_st
*memc
)
4915 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4917 // Since we blocked timed delete, this test is no longer valid.
4919 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4920 test_true(memc_clone
);
4921 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4923 memcached_server_instance_st instance
=
4924 memcached_server_instance_by_position(memc_clone
, 0);
4926 if (instance
->major_version
> 1 ||
4927 (instance
->major_version
== 1 &&
4928 instance
->minor_version
> 2))
4930 /* Binary protocol doesn't support deferred delete */
4931 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4932 test_true(bin_clone
);
4933 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4934 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4935 memcached_free(bin_clone
);
4937 memcached_quit(memc_clone
);
4939 /* If we know the server version, deferred delete should fail
4940 * with invalid arguments */
4941 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4943 /* If we don't know the server version, we should get a protocol error */
4944 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4946 /* but there is a bug in some of the memcached servers (1.4) that treats
4947 * the counter as noreply so it doesn't send the proper error message
4949 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4951 /* And buffered mode should be disabled and we should get protocol error */
4952 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4953 rc
= memcached_delete(memc
, "foo", 3, 1);
4954 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4956 /* Same goes for noreply... */
4957 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4958 rc
= memcached_delete(memc
, "foo", 3, 1);
4959 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4961 /* but a normal request should go through (and be buffered) */
4962 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4963 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4965 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4966 /* unbuffered noreply should be success */
4967 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4968 /* unbuffered with reply should be not found... */
4969 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4970 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4973 memcached_free(memc_clone
);
4976 return TEST_SUCCESS
;
4980 /* Test memcached_server_get_last_disconnect
4981 * For a working server set, shall be NULL
4982 * For a set of non existing server, shall not be NULL
4984 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4986 memcached_return_t rc
;
4987 memcached_server_instance_st disconnected_server
;
4989 /* With the working set of server */
4990 const char *key
= "marmotte";
4991 const char *value
= "milka";
4993 memcached_reset_last_disconnected_server(memc
);
4994 test_false(memc
->last_disconnected_server
);
4995 rc
= memcached_set(memc
, key
, strlen(key
),
4996 value
, strlen(value
),
4997 (time_t)0, (uint32_t)0);
4998 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5000 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5001 test_false(disconnected_server
);
5003 /* With a non existing server */
5005 memcached_server_st
*servers
;
5007 const char *server_list
= "localhost:9";
5009 servers
= memcached_servers_parse(server_list
);
5011 mine
= memcached_create(NULL
);
5012 rc
= memcached_server_push(mine
, servers
);
5013 test_compare(MEMCACHED_SUCCESS
, rc
);
5014 memcached_server_list_free(servers
);
5017 rc
= memcached_set(mine
, key
, strlen(key
),
5018 value
, strlen(value
),
5019 (time_t)0, (uint32_t)0);
5020 test_true(memcached_failed(rc
));
5022 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5023 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5024 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5025 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5027 memcached_quit(mine
);
5028 memcached_free(mine
);
5030 return TEST_SUCCESS
;
5033 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5035 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5036 char buffer
[BUFSIZ
];
5038 test_compare(MEMCACHED_SUCCESS
,
5039 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5041 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5044 // We will just use the error strings as our keys
5045 uint32_t counter
= 100;
5048 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5050 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5051 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5052 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
5054 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5055 test_true(disconnected_server
);
5056 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5057 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5061 memcached_reset_last_disconnected_server(memc
);
5066 memcached_free(memc
);
5068 return TEST_SUCCESS
;
5071 static test_return_t
test_verbosity(memcached_st
*memc
)
5073 memcached_verbosity(memc
, 3);
5075 return TEST_SUCCESS
;
5079 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5080 const char *key
, size_t key_length
,
5081 const char *value
, size_t value_length
,
5091 return MEMCACHED_SUCCESS
;
5094 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5096 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5097 test_compare(MEMCACHED_SUCCESS
, rc
);
5099 test_compare(MEMCACHED_SUCCESS
,
5100 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
5102 test_compare(MEMCACHED_SUCCESS
,
5103 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
5105 test_compare(MEMCACHED_SUCCESS
,
5106 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
5108 return TEST_SUCCESS
;
5112 * This test ensures that the failure counter isn't incremented during
5113 * normal termination of the memcached instance.
5115 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5117 memcached_return_t rc
;
5118 memcached_server_instance_st instance
;
5120 /* Set value to force connection to the server */
5121 const char *key
= "marmotte";
5122 const char *value
= "milka";
5125 * Please note that I'm abusing the internal structures in libmemcached
5126 * in a non-portable way and you shouldn't be doing this. I'm only
5127 * doing this in order to verify that the library works the way it should
5129 uint32_t number_of_hosts
= memcached_server_count(memc
);
5130 memc
->number_of_hosts
= 1;
5132 /* Ensure that we are connected to the server by setting a value */
5133 rc
= memcached_set(memc
, key
, strlen(key
),
5134 value
, strlen(value
),
5135 (time_t)0, (uint32_t)0);
5136 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5139 instance
= memcached_server_instance_by_position(memc
, 0);
5140 /* The test is to see that the memcached_quit doesn't increase the
5141 * the server failure conter, so let's ensure that it is zero
5142 * before sending quit
5144 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5146 memcached_quit(memc
);
5148 /* Verify that it memcached_quit didn't increment the failure counter
5149 * Please note that this isn't bullet proof, because an error could
5152 test_zero(instance
->server_failure_counter
);
5154 /* restore the instance */
5155 memc
->number_of_hosts
= number_of_hosts
;
5157 return TEST_SUCCESS
;
5161 * This tests ensures expected disconnections (for some behavior changes
5162 * for instance) do not wrongly increase failure counter
5164 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5166 /* Set value to force connection to the server */
5167 const char *key
= "marmotte";
5168 const char *value
= "milka";
5170 test_compare_hint(MEMCACHED_SUCCESS
,
5171 memcached_set(memc
, key
, strlen(key
),
5172 value
, strlen(value
),
5173 (time_t)0, (uint32_t)0),
5174 memcached_last_error_message(memc
));
5177 /* put failure limit to 1 */
5178 test_compare(MEMCACHED_SUCCESS
,
5179 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
5181 /* Put a retry timeout to effectively activate failure_limit effect */
5182 test_compare(MEMCACHED_SUCCESS
,
5183 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
5185 /* change behavior that triggers memcached_quit()*/
5186 test_compare(MEMCACHED_SUCCESS
,
5187 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
5190 /* Check if we still are connected */
5192 size_t string_length
;
5193 memcached_return rc
;
5194 char *string
= memcached_get(memc
, key
, strlen(key
),
5195 &string_length
, &flags
, &rc
);
5197 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5201 return TEST_SUCCESS
;
5206 * Test that ensures mget_execute does not end into recursive calls that finally fails
5208 static test_return_t
regression_bug_490486(memcached_st
*original_memc
)
5212 return TEST_SKIPPED
; // My MAC can't handle this test
5215 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
5218 * I only want to hit _one_ server so I know the number of requests I'm
5219 * sending in the pipeline.
5221 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
5224 size_t max_keys
= 20480;
5226 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5227 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5229 /* First add all of the items.. */
5230 char blob
[1024]= { 0 };
5231 for (size_t x
= 0; x
< max_keys
; ++x
)
5234 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5237 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5238 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5243 /* Try to get all of them with a large multiget */
5245 memcached_execute_function callbacks
[]= { &callback_counter
};
5246 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5247 (size_t)max_keys
, callbacks
, &counter
, 1);
5248 test_compare(MEMCACHED_SUCCESS
, rc
);
5250 char* the_value
= NULL
;
5251 char the_key
[MEMCACHED_MAX_KEY
];
5252 size_t the_key_length
;
5253 size_t the_value_length
;
5257 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5259 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5265 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5268 test_compare(MEMCACHED_END
, rc
);
5270 /* Verify that we got all of the items */
5271 test_compare(counter
, max_keys
);
5274 /* Release all allocated resources */
5275 for (size_t x
= 0; x
< max_keys
; ++x
)
5282 memcached_free(memc
);
5284 return TEST_SUCCESS
;
5287 static test_return_t
regression_bug_583031(memcached_st
*)
5289 memcached_st
*memc
= memcached_create(NULL
);
5291 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5293 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5294 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5295 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5296 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5297 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5298 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5300 memcached_return_t rc
;
5304 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5308 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5310 memcached_free(memc
);
5312 return TEST_SUCCESS
;
5315 static test_return_t
regression_bug_581030(memcached_st
*)
5318 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5319 test_false(local_stat
);
5321 memcached_stat_free(NULL
, NULL
);
5324 return TEST_SUCCESS
;
5327 #define regression_bug_655423_COUNT 6000
5328 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5330 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5331 memc
= NULL
; // Just to make sure it is not used
5336 return TEST_SKIPPED
;
5339 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5340 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5341 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5342 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5344 memset(payload
, int('x'), sizeof(payload
));
5346 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5348 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5349 snprintf(key
, sizeof(key
), "%u", x
);
5351 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5354 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5356 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5357 snprintf(key
, sizeof(key
), "%u", x
);
5359 size_t value_length
;
5360 memcached_return_t rc
;
5361 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5363 if (rc
== MEMCACHED_NOTFOUND
)
5366 test_zero(value_length
);
5370 test_compare(MEMCACHED_SUCCESS
, rc
);
5372 test_compare(100LLU, value_length
);
5376 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5377 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5378 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5380 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5381 snprintf(key
, sizeof(key
), "%u", x
);
5383 keys
[x
]= strdup(key
);
5385 key_length
[x
]= strlen(key
);
5386 test_true(key_length
[x
]);
5389 test_compare(MEMCACHED_SUCCESS
,
5390 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5393 memcached_result_st
*result
= NULL
;
5394 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5396 test_compare(size_t(100), memcached_result_length(result
));
5400 test_true(count
> 100); // If we don't get back atleast this, something is up
5402 /* Release all allocated resources */
5403 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5411 memcached_free(clone
);
5413 return TEST_SUCCESS
;
5417 * Test that ensures that buffered set to not trigger problems during io_flush
5419 #define regression_bug_490520_COUNT 200480
5420 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5422 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5423 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5424 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5425 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5426 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5428 memc
->number_of_hosts
= 1;
5430 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5431 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5433 /* First add all of the items.. */
5434 char blob
[3333] = {0};
5435 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5438 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5442 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5443 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
5446 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5453 return TEST_SUCCESS
;
5457 static test_return_t
regression_bug_854604(memcached_st
*)
5461 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
5463 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
5465 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
5466 test_compare(buffer
[0], 0);
5468 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
5469 test_true(strlen(buffer
));
5471 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
5472 test_true(strlen(buffer
));
5474 return TEST_SUCCESS
;
5477 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5479 fprintf(stderr
, "Iteration #%u: ", it
);
5481 if (error
== MEMCACHED_ERRNO
)
5483 fprintf(stderr
, "system error %d from %s: %s\n",
5484 errno
, what
, strerror(errno
));
5488 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5489 memcached_strerror(mc
, error
));
5493 #define TEST_CONSTANT_CREATION 200
5495 static test_return_t
regression_bug_(memcached_st
*memc
)
5497 const char *remote_server
;
5500 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5502 return TEST_SKIPPED
;
5505 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5507 memcached_st
* mc
= memcached_create(NULL
);
5508 memcached_return rc
;
5510 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5511 if (rc
!= MEMCACHED_SUCCESS
)
5513 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5516 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5517 if (rc
!= MEMCACHED_SUCCESS
)
5519 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5522 rc
= memcached_server_add(mc
, remote_server
, 0);
5523 if (rc
!= MEMCACHED_SUCCESS
)
5525 memcached_die(mc
, rc
, "memcached_server_add", x
);
5528 const char *set_key
= "akey";
5529 const size_t set_key_len
= strlen(set_key
);
5530 const char *set_value
= "a value";
5531 const size_t set_value_len
= strlen(set_value
);
5533 if (rc
== MEMCACHED_SUCCESS
)
5537 size_t get_value_len
;
5539 uint32_t get_value_flags
;
5541 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5542 &get_value_flags
, &rc
);
5543 if (rc
!= MEMCACHED_SUCCESS
)
5545 memcached_die(mc
, rc
, "memcached_get", x
);
5551 (get_value_len
!= set_value_len
5552 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5554 fprintf(stderr
, "Values don't match?\n");
5555 rc
= MEMCACHED_FAILURE
;
5561 rc
= memcached_set(mc
,
5562 set_key
, set_key_len
,
5563 set_value
, set_value_len
,
5567 if (rc
!= MEMCACHED_SUCCESS
)
5569 memcached_die(mc
, rc
, "memcached_set", x
);
5576 if (rc
!= MEMCACHED_SUCCESS
)
5582 return TEST_SUCCESS
;
5585 /* Clean the server before beginning testing */
5587 {"util_version", true, (test_callback_fn
*)util_version_test
},
5588 {"flush", false, (test_callback_fn
*)flush_test
},
5589 {"init", false, (test_callback_fn
*)init_test
},
5590 {"allocation", false, (test_callback_fn
*)allocation_test
},
5591 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5592 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5593 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5594 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5595 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5596 {"clone_test", false, (test_callback_fn
*)clone_test
},
5597 {"connection_test", false, (test_callback_fn
*)connection_test
},
5598 {"callback_test", false, (test_callback_fn
*)callback_test
},
5599 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5600 {"memcached_set()", false, (test_callback_fn
*)set_test
},
5601 {"memcached_set() 2", false, (test_callback_fn
*)set_test2
},
5602 {"memcached_set() 3", false, (test_callback_fn
*)set_test3
},
5603 {"add", true, (test_callback_fn
*)add_test
},
5604 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5605 {"replace", true, (test_callback_fn
*)replace_test
},
5606 {"delete", true, (test_callback_fn
*)delete_test
},
5607 {"get", true, (test_callback_fn
*)get_test
},
5608 {"get2", false, (test_callback_fn
*)get_test2
},
5609 {"get3", false, (test_callback_fn
*)get_test3
},
5610 {"get4", false, (test_callback_fn
*)get_test4
},
5611 {"partial mget", false, (test_callback_fn
*)get_test5
},
5612 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5613 {"increment", false, (test_callback_fn
*)increment_test
},
5614 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5615 {"decrement", false, (test_callback_fn
*)decrement_test
},
5616 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5617 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5618 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5619 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5620 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5621 {"binary_increment_with_prefix", 1, (test_callback_fn
*)binary_increment_with_prefix_test
},
5622 {"quit", false, (test_callback_fn
*)quit_test
},
5623 {"mget", true, (test_callback_fn
*)mget_test
},
5624 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5625 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5626 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5627 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5628 {"mget_end", false, (test_callback_fn
*)mget_end
},
5629 {"get_stats", false, (test_callback_fn
*)get_stats
},
5630 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5631 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5632 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5633 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
5634 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5635 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5636 {"read_through", true, (test_callback_fn
*)read_through
},
5637 {"delete_through", true, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER
},
5638 {"noreply", true, (test_callback_fn
*)noreply_test
},
5639 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5640 {"memcached_pool_st", true, (test_callback_fn
*)connection_pool_test
},
5641 {"memcached_pool_st #2", true, (test_callback_fn
*)connection_pool2_test
},
5643 {"memcached_pool_st #3", true, (test_callback_fn
*)connection_pool3_test
},
5645 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
5646 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
5647 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
5648 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
5649 {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_NOTFOUND
},
5650 {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_SUCCESS
},
5651 {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_by_key_NOTFOUND
},
5652 {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_by_key_SUCCESS
},
5653 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5654 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5656 {"memcached_dump() no data", true, (test_callback_fn
*)memcached_dump_TEST
},
5658 {"memcached_dump() with data", true, (test_callback_fn
*)memcached_dump_TEST2
},
5662 test_st touch_tests
[] ={
5663 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5664 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5668 test_st memcached_stat_tests
[] ={
5669 {"memcached_stat() INVALID ARG", 0, (test_callback_fn
*)memcached_stat_TEST
},
5670 {"memcached_stat()", 0, (test_callback_fn
*)memcached_stat_TEST2
},
5674 test_st behavior_tests
[] ={
5675 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5676 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5677 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5678 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5679 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5680 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5681 {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test
},
5682 {"MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY", false, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY
},
5686 test_st libmemcachedutil_tests
[] ={
5687 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5688 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5689 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5693 test_st basic_tests
[] ={
5694 {"init", true, (test_callback_fn
*)basic_init_test
},
5695 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5696 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5697 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5698 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5699 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5700 {"memcached_return_t", false, (test_callback_fn
*)memcached_return_t_TEST
},
5704 test_st regression_binary_vs_block
[] ={
5705 {"block add", true, (test_callback_fn
*)block_add_regression
},
5706 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
5710 test_st async_tests
[] ={
5711 {"add", true, (test_callback_fn
*)add_wrapper
},
5715 test_st memcached_server_get_last_disconnect_tests
[] ={
5716 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
5717 {0, 0, (test_callback_fn
*)0}
5721 test_st result_tests
[] ={
5722 {"result static", false, (test_callback_fn
*)result_static
},
5723 {"result alloc", false, (test_callback_fn
*)result_alloc
},
5724 {0, 0, (test_callback_fn
*)0}
5727 test_st version_1_2_3
[] ={
5728 {"append", false, (test_callback_fn
*)append_test
},
5729 {"prepend", false, (test_callback_fn
*)prepend_test
},
5730 {"cas", false, (test_callback_fn
*)cas_test
},
5731 {"cas2", false, (test_callback_fn
*)cas2_test
},
5732 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
5733 {0, 0, (test_callback_fn
*)0}
5736 test_st haldenbrand_tests
[] ={
5737 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
5738 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
5739 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
5740 {0, 0, (test_callback_fn
*)0}
5743 test_st user_tests
[] ={
5744 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
5745 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
5746 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
5747 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
5748 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
5749 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
5750 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
5751 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
5752 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
5753 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
5754 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
5755 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
5756 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
5757 #if !defined(__sun) && !defined(__OpenBSD__)
5759 ** It seems to be something weird with the character sets..
5760 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5761 ** guess I need to find out how this is supposed to work.. Perhaps I need
5762 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5763 ** so just disable the code for now...).
5765 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
5767 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
5768 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
5769 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
5770 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
5771 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
5772 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
5773 {0, 0, (test_callback_fn
*)0}
5776 test_st replication_tests
[]= {
5777 {"set", true, (test_callback_fn
*)replication_set_test
},
5778 {"get", false, (test_callback_fn
*)replication_get_test
},
5779 {"mget", false, (test_callback_fn
*)replication_mget_test
},
5780 {"delete", true, (test_callback_fn
*)replication_delete_test
},
5781 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
5782 {"miss", false, (test_callback_fn
*)replication_miss_test
},
5783 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
5784 {0, 0, (test_callback_fn
*)0}
5788 * The following test suite is used to verify that we don't introduce
5789 * regression bugs. If you want more information about the bug / test,
5790 * you should look in the bug report at
5791 * http://bugs.launchpad.net/libmemcached
5793 test_st regression_tests
[]= {
5794 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
5795 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
5796 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
5797 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
5798 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
5799 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
5800 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
5801 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
5802 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
5803 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
5804 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
5805 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
5806 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
5807 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
5808 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
5809 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
5810 {"lp:854604", true, (test_callback_fn
*)regression_bug_854604
},
5811 {0, false, (test_callback_fn
*)0}
5814 test_st ketama_compatibility
[]= {
5815 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
5816 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
5817 {0, 0, (test_callback_fn
*)0}
5820 test_st generate_tests
[] ={
5821 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5822 {"generate_data", true, (test_callback_fn
*)generate_data
},
5823 {"get_read", false, (test_callback_fn
*)get_read
},
5824 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
5825 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5826 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
5827 {"generate_data", true, (test_callback_fn
*)generate_data
},
5828 {"mget_read", false, (test_callback_fn
*)mget_read
},
5829 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
5830 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
5831 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
5832 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
5833 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5834 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
5835 {"generate_data", true, (test_callback_fn
*)generate_data
},
5836 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5837 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5838 {0, 0, (test_callback_fn
*)0}
5841 test_st consistent_tests
[] ={
5842 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5843 {"generate_data", true, (test_callback_fn
*)generate_data
},
5844 {"get_read", 0, (test_callback_fn
*)get_read_count
},
5845 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5846 {0, 0, (test_callback_fn
*)0}
5849 test_st consistent_weighted_tests
[] ={
5850 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5851 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
5852 {"get_read", false, (test_callback_fn
*)get_read_count
},
5853 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5854 {0, 0, (test_callback_fn
*)0}
5857 test_st hsieh_availability
[] ={
5858 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
5859 {0, 0, (test_callback_fn
*)0}
5862 test_st murmur_availability
[] ={
5863 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
5864 {0, 0, (test_callback_fn
*)0}
5868 test_st hash_sanity
[] ={
5869 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
5870 {0, 0, (test_callback_fn
*)0}
5874 test_st ketama_auto_eject_hosts
[] ={
5875 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
5876 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
5877 {0, 0, (test_callback_fn
*)0}
5880 test_st hash_tests
[] ={
5881 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
5882 {"md5", false, (test_callback_fn
*)md5_run
},
5883 {"crc", false, (test_callback_fn
*)crc_run
},
5884 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
5885 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
5886 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
5887 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
5888 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
5889 {"murmur", false, (test_callback_fn
*)murmur_run
},
5890 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
5891 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
5892 {0, 0, (test_callback_fn
*)0}
5895 test_st error_conditions
[] ={
5896 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
5897 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
5898 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
5899 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5900 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5901 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
5902 {0, 0, (test_callback_fn
*)0}
5905 test_st parser_tests
[] ={
5906 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
5907 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
5908 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
5909 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
5910 {"hash", false, (test_callback_fn
*)parser_hash_test
},
5911 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
5912 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
5913 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
5914 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
5915 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
5916 {"server", false, (test_callback_fn
*)server_test
},
5917 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
5918 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
5919 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
5920 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
5921 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
5922 {0, 0, (test_callback_fn
*)0}
5925 test_st virtual_bucket_tests
[] ={
5926 {"basic", false, (test_callback_fn
*)virtual_back_map
},
5927 {0, 0, (test_callback_fn
*)0}
5930 test_st memcached_server_add_tests
[] ={
5931 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
5932 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
5933 {0, 0, (test_callback_fn
*)0}
5936 test_st namespace_tests
[] ={
5937 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
5938 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
5939 {0, 0, (test_callback_fn
*)0}
5942 collection_st collection
[] ={
5944 {"hash_sanity", 0, 0, hash_sanity
},
5946 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
5947 {"basic", 0, 0, basic_tests
},
5948 {"hsieh_availability", 0, 0, hsieh_availability
},
5949 {"murmur_availability", 0, 0, murmur_availability
},
5950 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
5951 {"block", 0, 0, tests
},
5952 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
5953 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
5954 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5955 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
5956 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
5957 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
5958 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
5959 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
5960 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
5961 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
5962 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
5963 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
5964 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
5965 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
5966 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
5967 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5968 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
5969 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
5970 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
5971 #ifdef MEMCACHED_ENABLE_DEPRECATED
5972 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
5974 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
5975 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
5976 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
5977 {"specific namespace", 0, 0, namespace_tests
},
5978 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
5979 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
5980 {"result", 0, 0, result_tests
},
5981 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
5982 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
5983 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
5984 {"user written tests", 0, 0, user_tests
},
5985 {"generate", 0, 0, generate_tests
},
5986 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
5987 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
5988 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
5989 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
5990 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
5991 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
5992 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
5994 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
5995 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
5996 {"consistent_not", 0, 0, consistent_tests
},
5997 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
5998 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
5999 {"ketama_compat", 0, 0, ketama_compatibility
},
6000 {"test_hashes", 0, 0, hash_tests
},
6001 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6002 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6003 {"regression", 0, 0, regression_tests
},
6004 {"behaviors", 0, 0, behavior_tests
},
6005 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6006 {"error_conditions", 0, 0, error_conditions
},
6007 {"parser", 0, 0, parser_tests
},
6008 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6009 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6010 {"touch", 0, 0, touch_tests
},
6011 {"touch", (test_callback_fn
*)pre_binary
, 0, touch_tests
},
6012 {"memcached_stat()", 0, 0, memcached_stat_tests
},
6016 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
6018 #include "tests/libmemcached_world.h"
6020 void get_world(Framework
*world
)
6022 world
->collections
= collection
;
6024 world
->_create
= (test_callback_create_fn
*)world_create
;
6025 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6027 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6028 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6029 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6030 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6031 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6033 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6034 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6036 world
->set_runner(&defualt_libmemcached_runner
);
6038 world
->set_socket();