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/memcached.h>
46 #include <libmemcached/is.h>
47 #include <libmemcached/server_instance.h>
49 #include <libhashkit/hashkit.h>
58 #include <sys/types.h>
63 #include <libtest/server.h>
65 #include "clients/generator.h"
66 #include "clients/execute.h"
68 #define SMALL_STRING_LEN 1024
70 #include <libtest/test.hpp>
72 #include "tests/basic.h"
73 #include "tests/debug.h"
74 #include "tests/deprecated.h"
75 #include "tests/error_conditions.h"
76 #include "tests/exist.h"
77 #include "tests/ketama.h"
78 #include "tests/namespace.h"
79 #include "tests/parser.h"
80 #include "tests/pool.h"
81 #include "tests/print.h"
82 #include "tests/replication.h"
83 #include "tests/server_add.h"
84 #include "tests/virtual_buckets.h"
86 using namespace libtest
;
88 #include <libmemcached/memcached_util.h>
90 #include "hash_results.h"
92 #define GLOBAL_COUNT 10000
93 #define GLOBAL2_COUNT 100
94 #define SERVERS_TO_CREATE 5
95 static uint32_t global_count
;
97 static pairs_st
*global_pairs
;
98 static const char *global_keys
[GLOBAL_COUNT
];
99 static size_t global_keys_length
[GLOBAL_COUNT
];
102 static test_return_t
pre_binary(memcached_st
*memc
);
105 static test_return_t
init_test(memcached_st
*not_used
)
110 (void)memcached_create(&memc
);
111 memcached_free(&memc
);
116 #define TEST_PORT_COUNT 7
117 in_port_t test_ports
[TEST_PORT_COUNT
];
119 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
120 const memcached_server_st
*server
,
124 size_t bigger
= *((size_t *)(context
));
126 assert(bigger
<= memcached_server_port(server
));
127 *((size_t *)(context
))= memcached_server_port(server
);
129 return MEMCACHED_SUCCESS
;
132 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
133 const memcached_server_st
*instance
,
137 FILE *stream
= (FILE *)context
;
140 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
141 memcached_server_name(instance
),
142 memcached_server_port(instance
),
143 instance
->major_version
,
144 instance
->minor_version
,
145 instance
->micro_version
);
147 return MEMCACHED_SUCCESS
;
150 static test_return_t
server_sort_test(memcached_st
*ptr
)
152 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
154 memcached_return_t rc
;
155 memcached_server_fn callbacks
[1];
156 memcached_st
*local_memc
;
159 local_memc
= memcached_create(NULL
);
160 test_true(local_memc
);
161 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
163 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
165 test_ports
[x
]= (in_port_t
)random() % 64000;
166 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
167 test_compare(memcached_server_count(local_memc
), x
+1);
169 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
171 test_compare(MEMCACHED_SUCCESS
, rc
);
174 callbacks
[0]= server_display_function
;
175 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
178 memcached_free(local_memc
);
183 static test_return_t
server_sort2_test(memcached_st
*ptr
)
185 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
186 memcached_server_fn callbacks
[1];
187 memcached_st
*local_memc
;
188 memcached_server_instance_st instance
;
191 local_memc
= memcached_create(NULL
);
192 test_true(local_memc
);
193 test_compare(MEMCACHED_SUCCESS
,
194 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
196 test_compare(MEMCACHED_SUCCESS
,
197 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
198 instance
= memcached_server_instance_by_position(local_memc
, 0);
199 test_compare(in_port_t(43043), memcached_server_port(instance
));
201 test_compare(MEMCACHED_SUCCESS
,
202 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
204 instance
= memcached_server_instance_by_position(local_memc
, 0);
205 test_compare(in_port_t(43042), memcached_server_port(instance
));
207 instance
= memcached_server_instance_by_position(local_memc
, 1);
208 test_compare(in_port_t(43043), memcached_server_port(instance
));
210 callbacks
[0]= server_display_function
;
211 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
214 memcached_free(local_memc
);
219 static test_return_t
memcached_server_remove_test(memcached_st
*)
221 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";
224 test_compare(MEMCACHED_SUCCESS
,
225 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
226 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
229 memcached_server_fn callbacks
[1];
230 callbacks
[0]= server_print_callback
;
231 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
233 memcached_free(memc
);
238 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
239 const memcached_server_st
*server
,
243 uint32_t x
= *((uint32_t *)(context
));
245 if (! (test_ports
[x
] == server
->port
))
247 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
248 return MEMCACHED_FAILURE
;
251 *((uint32_t *)(context
))= ++x
;
253 return MEMCACHED_SUCCESS
;
256 static test_return_t
server_unsort_test(memcached_st
*ptr
)
258 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
259 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
260 memcached_server_fn callbacks
[1];
261 memcached_st
*local_memc
;
264 local_memc
= memcached_create(NULL
);
265 test_true(local_memc
);
267 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
269 test_ports
[x
]= (in_port_t
)(random() % 64000);
270 test_compare(MEMCACHED_SUCCESS
,
271 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
272 test_compare(memcached_server_count(local_memc
), x
+1);
274 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
278 callbacks
[0]= server_display_unsort_function
;
279 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
281 /* Now we sort old data! */
282 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
283 callbacks
[0]= server_display_function
;
284 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
287 memcached_free(local_memc
);
292 static test_return_t
allocation_test(memcached_st
*not_used
)
296 memc
= memcached_create(NULL
);
298 memcached_free(memc
);
303 static test_return_t
clone_test(memcached_st
*memc
)
307 memcached_st
*memc_clone
;
308 memc_clone
= memcached_clone(NULL
, NULL
);
309 test_true(memc_clone
);
310 memcached_free(memc_clone
);
313 /* Can we init from null? */
315 memcached_st
*memc_clone
;
316 memc_clone
= memcached_clone(NULL
, memc
);
317 test_true(memc_clone
);
320 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
321 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
322 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
323 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
326 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
327 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
328 test_true(memc_clone
->distribution
== memc
->distribution
);
329 { // Test all of the flags
330 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
331 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
332 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
333 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
334 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
335 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
336 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
337 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
338 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
339 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
340 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
341 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
342 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
344 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
345 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
346 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
347 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
348 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
349 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
350 test_true(memc_clone
->on_clone
== memc
->on_clone
);
351 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
352 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
353 test_true(memc_clone
->recv_size
== memc
->recv_size
);
354 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
355 test_true(memc_clone
->send_size
== memc
->send_size
);
356 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
357 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
358 test_true(memc_clone
->user_data
== memc
->user_data
);
360 memcached_free(memc_clone
);
363 /* Can we init from struct? */
365 memcached_st declared_clone
;
366 memcached_st
*memc_clone
;
367 memset(&declared_clone
, 0 , sizeof(memcached_st
));
368 memc_clone
= memcached_clone(&declared_clone
, NULL
);
369 test_true(memc_clone
);
370 memcached_free(memc_clone
);
373 /* Can we init from struct? */
375 memcached_st declared_clone
;
376 memcached_st
*memc_clone
;
377 memset(&declared_clone
, 0 , sizeof(memcached_st
));
378 memc_clone
= memcached_clone(&declared_clone
, memc
);
379 test_true(memc_clone
);
380 memcached_free(memc_clone
);
386 static test_return_t
userdata_test(memcached_st
*memc
)
389 test_false(memcached_set_user_data(memc
, foo
));
390 test_true(memcached_get_user_data(memc
) == foo
);
391 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
396 static test_return_t
connection_test(memcached_st
*memc
)
398 test_compare(MEMCACHED_SUCCESS
,
399 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
404 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
406 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
408 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
410 test_compare(36, int(MEMCACHED_BEHAVIOR_MAX
));
415 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
417 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
419 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
421 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
426 static test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
428 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
429 982370485U, 1263635348U, 4242906218U, 3829656100U,
430 1891735253U, 334139633U, 2257084983U, 3088286104U,
431 13199785U, 2542027183U, 1097051614U, 199566778U,
432 2748246961U, 2465192557U, 1664094137U, 2405439045U,
433 1842224848U, 692413798U, 3479807801U, 919913813U,
434 4269430871U, 610793021U, 527273862U, 1437122909U,
435 2300930706U, 2943759320U, 674306647U, 2400528935U,
436 54481931U, 4186304426U, 1741088401U, 2979625118U,
437 4159057246U, 3425930182U, 2593724503U, 1868899624U,
438 1769812374U, 2302537950U, 1110330676U, 3365377466U,
439 1336171666U, 3021258493U, 2334992265U, 3861994737U,
442 // You have updated the memcache_error messages but not updated docs/tests.
443 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
446 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
447 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
448 MEMCACHED_HASH_JENKINS
);
449 if (values
[rc
] != hash_val
)
451 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
452 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
454 test_compare(values
[rc
], hash_val
);
456 test_compare(48, int(MEMCACHED_MAXIMUM_RETURN
));
461 static test_return_t
set_test(memcached_st
*memc
)
463 memcached_return_t rc
= memcached_set(memc
,
464 test_literal_param("foo"),
465 test_literal_param("when we sanitize"),
466 time_t(0), (uint32_t)0);
467 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
472 static test_return_t
append_test(memcached_st
*memc
)
474 memcached_return_t rc
;
475 const char *key
= "fig";
476 const char *in_value
= "we";
477 char *out_value
= NULL
;
481 rc
= memcached_flush(memc
, 0);
482 test_compare(MEMCACHED_SUCCESS
, rc
);
484 rc
= memcached_set(memc
, key
, strlen(key
),
485 in_value
, strlen(in_value
),
486 (time_t)0, (uint32_t)0);
487 test_compare(MEMCACHED_SUCCESS
, rc
);
489 rc
= memcached_append(memc
, key
, strlen(key
),
490 " the", strlen(" the"),
491 (time_t)0, (uint32_t)0);
492 test_compare(MEMCACHED_SUCCESS
, rc
);
494 rc
= memcached_append(memc
, key
, strlen(key
),
495 " people", strlen(" people"),
496 (time_t)0, (uint32_t)0);
497 test_compare(MEMCACHED_SUCCESS
, rc
);
499 out_value
= memcached_get(memc
, key
, strlen(key
),
500 &value_length
, &flags
, &rc
);
501 test_memcmp(out_value
, "we the people", strlen("we the people"));
502 test_compare(strlen("we the people"), value_length
);
503 test_compare(MEMCACHED_SUCCESS
, rc
);
509 static test_return_t
append_binary_test(memcached_st
*memc
)
511 memcached_return_t rc
;
512 const char *key
= "numbers";
513 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
519 rc
= memcached_flush(memc
, 0);
520 test_compare(MEMCACHED_SUCCESS
, rc
);
522 rc
= memcached_set(memc
,
525 (time_t)0, (uint32_t)0);
526 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
528 for (x
= 0; store_list
[x
] ; x
++)
530 rc
= memcached_append(memc
,
532 (char *)&store_list
[x
], sizeof(uint32_t),
533 (time_t)0, (uint32_t)0);
534 test_compare(MEMCACHED_SUCCESS
, rc
);
537 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
538 &value_length
, &flags
, &rc
);
539 test_compare(value_length
, sizeof(uint32_t) * x
);
540 test_compare(MEMCACHED_SUCCESS
, rc
);
542 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
544 test_compare(*ptr
, store_list
[x
- counter
]);
552 static test_return_t
cas2_test(memcached_st
*memc
)
554 memcached_return_t rc
;
555 const char *keys
[]= {"fudge", "son", "food"};
556 size_t key_length
[]= {5, 3, 4};
557 const char *value
= "we the people";
558 size_t value_length
= strlen("we the people");
559 memcached_result_st results_obj
;
560 memcached_result_st
*results
;
563 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
565 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
567 for (uint32_t x
= 0; x
< 3; x
++)
569 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
570 keys
[x
], key_length
[x
],
571 (time_t)50, (uint32_t)9);
572 test_compare(MEMCACHED_SUCCESS
, rc
);
575 rc
= memcached_mget(memc
, keys
, key_length
, 3);
577 results
= memcached_result_create(memc
, &results_obj
);
579 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
581 test_true(results
->item_cas
);
582 test_compare(MEMCACHED_SUCCESS
, rc
);
583 test_true(memcached_result_cas(results
));
585 test_memcmp(value
, "we the people", strlen("we the people"));
586 test_compare(strlen("we the people"), value_length
);
587 test_compare(MEMCACHED_SUCCESS
, rc
);
589 memcached_result_free(&results_obj
);
594 static test_return_t
cas_test(memcached_st
*memc
)
596 memcached_return_t rc
;
597 const char *key
= "fun";
598 size_t key_length
= strlen(key
);
599 const char *value
= "we the people";
600 const char* keys
[2] = { key
, NULL
};
601 size_t keylengths
[2] = { strlen(key
), 0 };
602 size_t value_length
= strlen(value
);
603 const char *value2
= "change the value";
604 size_t value2_length
= strlen(value2
);
606 memcached_result_st results_obj
;
607 memcached_result_st
*results
;
610 rc
= memcached_flush(memc
, 0);
611 test_compare(MEMCACHED_SUCCESS
, rc
);
613 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
615 rc
= memcached_set(memc
, key
, strlen(key
),
616 value
, strlen(value
),
617 (time_t)0, (uint32_t)0);
618 test_compare(MEMCACHED_SUCCESS
, rc
);
620 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
622 results
= memcached_result_create(memc
, &results_obj
);
624 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
626 test_compare(MEMCACHED_SUCCESS
, rc
);
627 test_true(memcached_result_cas(results
));
628 test_memcmp(value
, memcached_result_value(results
), value_length
);
629 test_compare(strlen(memcached_result_value(results
)), value_length
);
630 test_compare(MEMCACHED_SUCCESS
, rc
);
631 uint64_t cas
= memcached_result_cas(results
);
634 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
635 test_true(rc
== MEMCACHED_END
);
636 test_true(results
== NULL
);
639 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
640 test_compare(MEMCACHED_SUCCESS
, rc
);
643 * The item will have a new cas value, so try to set it again with the old
644 * value. This should fail!
646 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
647 test_compare(MEMCACHED_DATA_EXISTS
, rc
);
649 memcached_result_free(&results_obj
);
654 static test_return_t
prepend_test(memcached_st
*memc
)
656 memcached_return_t rc
;
657 const char *key
= "fig";
658 const char *value
= "people";
659 char *out_value
= NULL
;
663 rc
= memcached_flush(memc
, 0);
664 test_compare(MEMCACHED_SUCCESS
, rc
);
666 rc
= memcached_set(memc
, key
, strlen(key
),
667 value
, strlen(value
),
668 (time_t)0, (uint32_t)0);
669 test_compare(MEMCACHED_SUCCESS
, rc
);
671 rc
= memcached_prepend(memc
, key
, strlen(key
),
672 "the ", strlen("the "),
673 (time_t)0, (uint32_t)0);
674 test_compare(MEMCACHED_SUCCESS
, rc
);
676 rc
= memcached_prepend(memc
, key
, strlen(key
),
677 "we ", strlen("we "),
678 (time_t)0, (uint32_t)0);
679 test_compare(MEMCACHED_SUCCESS
, rc
);
681 out_value
= memcached_get(memc
, key
, strlen(key
),
682 &value_length
, &flags
, &rc
);
683 test_memcmp(out_value
, "we the people", strlen("we the people"));
684 test_compare(strlen("we the people"), value_length
);
685 test_compare(MEMCACHED_SUCCESS
, rc
);
692 Set the value, then quit to make sure it is flushed.
693 Come back in and test that add fails.
695 static test_return_t
add_test(memcached_st
*memc
)
697 memcached_return_t rc
;
698 const char *key
= "foo";
699 const char *value
= "when we sanitize";
700 unsigned long long setting_value
;
702 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
704 rc
= memcached_set(memc
, key
, strlen(key
),
705 value
, strlen(value
),
706 (time_t)0, (uint32_t)0);
707 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
708 memcached_quit(memc
);
709 rc
= memcached_add(memc
, key
, strlen(key
),
710 value
, strlen(value
),
711 (time_t)0, (uint32_t)0);
713 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
716 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
720 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
727 ** There was a problem of leaking filedescriptors in the initial release
728 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
729 ** systems it seems that the kernel is slow on reclaiming the resources
730 ** because the connects starts to time out (the test doesn't do much
731 ** anyway, so just loop 10 iterations)
733 static test_return_t
add_wrapper(memcached_st
*memc
)
735 unsigned int max
= 10000;
743 for (uint32_t x
= 0; x
< max
; x
++)
749 static test_return_t
replace_test(memcached_st
*memc
)
751 memcached_return_t rc
;
752 const char *key
= "foo";
753 const char *value
= "when we sanitize";
754 const char *original
= "first we insert some data";
756 rc
= memcached_set(memc
, key
, strlen(key
),
757 original
, strlen(original
),
758 (time_t)0, (uint32_t)0);
759 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
761 test_compare(MEMCACHED_SUCCESS
,
762 memcached_replace(memc
, key
, strlen(key
),
763 value
, strlen(value
),
764 (time_t)0, (uint32_t)0));
769 static test_return_t
delete_test(memcached_st
*memc
)
771 memcached_return_t rc
;
772 const char *key
= "foo";
773 const char *value
= "when we sanitize";
775 rc
= memcached_set(memc
, key
, strlen(key
),
776 value
, strlen(value
),
777 (time_t)0, (uint32_t)0);
778 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
780 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
781 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
786 static test_return_t
flush_test(memcached_st
*memc
)
788 uint64_t query_id
= memcached_query_id(memc
);
789 test_compare(MEMCACHED_SUCCESS
,
790 memcached_flush(memc
, 0));
791 test_compare(query_id
+1, memcached_query_id(memc
));
796 static memcached_return_t
server_function(const memcached_st
*ptr
,
797 const memcached_server_st
*server
,
800 (void)ptr
; (void)server
; (void)context
;
803 return MEMCACHED_SUCCESS
;
806 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
809 strncpy(context
, "foo bad", sizeof(context
));
810 memcached_server_fn callbacks
[1];
812 callbacks
[0]= server_function
;
813 memcached_server_cursor(memc
, callbacks
, context
, 1);
817 static test_return_t
bad_key_test(memcached_st
*memc
)
819 memcached_return_t rc
;
820 const char *key
= "foo bad";
822 memcached_st
*memc_clone
;
823 size_t max_keylen
= 0xffff;
825 uint64_t query_id
= memcached_query_id(memc
);
827 // Just skip if we are in binary mode.
828 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
830 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
832 memc_clone
= memcached_clone(NULL
, memc
);
833 test_true(memc_clone
);
835 query_id
= memcached_query_id(memc_clone
);
836 test_compare(MEMCACHED_SUCCESS
,
837 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
838 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
840 /* All keys are valid in the binary protocol (except for length) */
841 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
843 query_id
= memcached_query_id(memc_clone
);
845 size_t string_length
;
846 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
847 &string_length
, &flags
, &rc
);
848 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
849 test_zero(string_length
);
853 query_id
= memcached_query_id(memc_clone
);
854 test_compare(MEMCACHED_SUCCESS
,
855 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
856 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
858 size_t string_length
;
859 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
860 &string_length
, &flags
, &rc
);
861 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
862 test_zero(string_length
);
866 /* Test multi key for bad keys */
867 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
868 size_t key_lengths
[] = { 7, 7, 7 };
869 query_id
= memcached_query_id(memc_clone
);
870 test_compare(MEMCACHED_SUCCESS
,
871 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
872 test_compare(query_id
, memcached_query_id(memc_clone
));
874 query_id
= memcached_query_id(memc_clone
);
875 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
876 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
877 test_compare(query_id
+1, memcached_query_id(memc_clone
));
879 query_id
= memcached_query_id(memc_clone
);
880 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
881 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
882 test_compare(query_id
+1, memcached_query_id(memc_clone
));
886 /* The following test should be moved to the end of this function when the
887 memcached server is updated to allow max size length of the keys in the
890 test_compare(MEMCACHED_SUCCESS
,
891 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
893 std::vector
<char> longkey
;
894 longkey
.insert(longkey
.end(), max_keylen
+1, 'a');
895 test_compare(longkey
.size(), max_keylen
+1);
897 size_t string_length
;
898 test_null(memcached_get(memc_clone
, &longkey
[0], max_keylen
, &string_length
, &flags
, &rc
));
899 test_compare(MEMCACHED_NOTFOUND
, rc
);
900 test_zero(string_length
);
902 test_null(memcached_get(memc_clone
, &longkey
[0], max_keylen
+1, &string_length
, &flags
, &rc
));
903 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
904 test_zero(string_length
);
908 /* Make sure zero length keys are marked as bad */
910 test_compare(MEMCACHED_SUCCESS
,
911 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
912 size_t string_length
;
913 char *string
= memcached_get(memc_clone
, key
, 0,
914 &string_length
, &flags
, &rc
);
915 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
916 test_zero(string_length
);
920 memcached_free(memc_clone
);
925 #define READ_THROUGH_VALUE "set for me"
926 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
929 memcached_result_st
*result
)
931 (void)memc
;(void)key
;(void)key_length
;
932 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
935 #ifndef __INTEL_COMPILER
936 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
939 static test_return_t
read_through(memcached_st
*memc
)
941 memcached_return_t rc
;
942 const char *key
= "foo";
944 size_t string_length
;
946 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
948 string
= memcached_get(memc
, key
, strlen(key
),
949 &string_length
, &flags
, &rc
);
951 test_compare(MEMCACHED_NOTFOUND
, rc
);
952 test_false(string_length
);
955 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
);
956 test_compare(MEMCACHED_SUCCESS
, rc
);
958 string
= memcached_get(memc
, key
, strlen(key
),
959 &string_length
, &flags
, &rc
);
961 test_compare(MEMCACHED_SUCCESS
, rc
);
962 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
963 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
964 test_strcmp(READ_THROUGH_VALUE
, string
);
967 string
= memcached_get(memc
, key
, strlen(key
),
968 &string_length
, &flags
, &rc
);
970 test_compare(MEMCACHED_SUCCESS
, rc
);
972 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
973 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
974 test_strcmp(READ_THROUGH_VALUE
, string
);
980 static memcached_return_t
delete_trigger(memcached_st
*,
987 return MEMCACHED_SUCCESS
;
990 static test_return_t
delete_through(memcached_st
*memc
)
992 memcached_trigger_delete_key_fn callback
;
994 callback
= (memcached_trigger_delete_key_fn
)delete_trigger
;
996 test_compare(MEMCACHED_SUCCESS
,
997 memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
));
1002 static test_return_t
get_test(memcached_st
*memc
)
1004 memcached_return_t rc
;
1005 const char *key
= "foo";
1007 size_t string_length
;
1010 uint64_t query_id
= memcached_query_id(memc
);
1011 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
1012 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
1013 test_compare(query_id
+1, memcached_query_id(memc
));
1015 string
= memcached_get(memc
, key
, strlen(key
),
1016 &string_length
, &flags
, &rc
);
1018 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1019 test_false(string_length
);
1022 return TEST_SUCCESS
;
1025 static test_return_t
get_test2(memcached_st
*memc
)
1027 const char *key
= "foo";
1028 const char *value
= "when we sanitize";
1030 uint64_t query_id
= memcached_query_id(memc
);
1031 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1032 value
, strlen(value
),
1033 (time_t)0, (uint32_t)0);
1034 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1035 test_compare(query_id
+1, memcached_query_id(memc
));
1037 query_id
= memcached_query_id(memc
);
1038 test_true(query_id
);
1041 size_t string_length
;
1042 char *string
= memcached_get(memc
, key
, strlen(key
),
1043 &string_length
, &flags
, &rc
);
1044 test_compare(query_id
+1, memcached_query_id(memc
));
1046 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1047 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1049 test_compare(strlen(value
), string_length
);
1050 test_memcmp(string
, value
, string_length
);
1054 return TEST_SUCCESS
;
1057 static test_return_t
set_test2(memcached_st
*memc
)
1059 const char *key
= "foo";
1060 const char *value
= "train in the brain";
1061 size_t value_length
= strlen(value
);
1063 for (uint32_t x
= 0; x
< 10; x
++)
1065 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1066 value
, value_length
,
1067 (time_t)0, (uint32_t)0);
1068 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1071 return TEST_SUCCESS
;
1074 static test_return_t
set_test3(memcached_st
*memc
)
1076 size_t value_length
= 8191;
1078 char *value
= (char*)malloc(value_length
);
1081 for (uint32_t x
= 0; x
< value_length
; x
++)
1083 value
[x
] = (char) (x
% 127);
1086 /* The dump test relies on there being at least 32 items in memcached */
1087 for (uint32_t x
= 0; x
< 32; x
++)
1091 snprintf(key
, sizeof(key
), "foo%u", x
);
1093 uint64_t query_id
= memcached_query_id(memc
);
1094 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1095 value
, value_length
,
1096 (time_t)0, (uint32_t)0);
1097 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1098 test_compare(query_id
+1, memcached_query_id(memc
));
1103 return TEST_SUCCESS
;
1106 static test_return_t
get_test3(memcached_st
*memc
)
1108 const char *key
= "foo";
1109 size_t value_length
= 8191;
1111 char *value
= (char*)malloc(value_length
);
1114 for (uint32_t x
= 0; x
< value_length
; x
++)
1116 value
[x
] = (char) (x
% 127);
1119 memcached_return_t rc
;
1120 rc
= memcached_set(memc
, key
, strlen(key
),
1121 value
, value_length
,
1122 (time_t)0, (uint32_t)0);
1123 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1125 size_t string_length
;
1127 char *string
= memcached_get(memc
, key
, strlen(key
),
1128 &string_length
, &flags
, &rc
);
1130 test_compare(MEMCACHED_SUCCESS
, rc
);
1132 test_compare(string_length
, value_length
);
1133 test_memcmp(string
, value
, string_length
);
1138 return TEST_SUCCESS
;
1141 static test_return_t
get_test4(memcached_st
*memc
)
1143 const char *key
= "foo";
1144 size_t value_length
= 8191;
1146 char *value
= (char*)malloc(value_length
);
1149 for (uint32_t x
= 0; x
< value_length
; x
++)
1151 value
[x
] = (char) (x
% 127);
1154 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1155 value
, value_length
,
1156 (time_t)0, (uint32_t)0);
1157 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1159 for (uint32_t x
= 0; x
< 10; x
++)
1162 size_t string_length
;
1163 char *string
= memcached_get(memc
, key
, strlen(key
),
1164 &string_length
, &flags
, &rc
);
1166 test_compare(MEMCACHED_SUCCESS
, rc
);
1168 test_compare(string_length
, value_length
);
1169 test_memcmp(string
, value
, string_length
);
1175 return TEST_SUCCESS
;
1179 * This test verifies that memcached_read_one_response doesn't try to
1180 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1181 * responses before you execute a storage command.
1183 static test_return_t
get_test5(memcached_st
*memc
)
1186 ** Request the same key twice, to ensure that we hash to the same server
1187 ** (so that we have multiple response values queued up) ;-)
1189 const char *keys
[]= { "key", "key" };
1190 size_t lengths
[]= { 3, 3 };
1194 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1195 keys
[0], lengths
[0], 0, 0);
1196 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1198 memcached_result_st results_obj
;
1199 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1202 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1205 memcached_result_free(&results_obj
);
1207 /* Don't read out the second result, but issue a set instead.. */
1208 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1210 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1211 &rlen
, &flags
, &rc
);
1213 test_compare(MEMCACHED_NOTFOUND
, rc
);
1214 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1216 test_compare(MEMCACHED_SUCCESS
, rc
);
1219 return TEST_SUCCESS
;
1222 static test_return_t
mget_end(memcached_st
*memc
)
1224 const char *keys
[]= { "foo", "foo2" };
1225 size_t lengths
[]= { 3, 4 };
1226 const char *values
[]= { "fjord", "41" };
1228 memcached_return_t rc
;
1231 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1233 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[x
], lengths
[x
], values
[x
], strlen(values
[x
]), (time_t)0, (uint32_t)0));
1237 size_t string_length
;
1240 // retrieve both via mget
1241 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1243 char key
[MEMCACHED_MAX_KEY
];
1246 // this should get both
1247 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1249 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1251 test_compare(MEMCACHED_SUCCESS
, rc
);
1253 if (key_length
== 4)
1258 test_compare(string_length
, strlen(values
[val
]));
1259 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1263 // this should indicate end
1264 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1265 test_compare(MEMCACHED_END
, rc
);
1268 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1269 test_compare(MEMCACHED_SUCCESS
, rc
);
1271 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1272 test_compare(key_length
, lengths
[0]);
1273 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1274 test_compare(string_length
, strlen(values
[0]));
1275 test_true(strncmp(values
[0], string
, string_length
) == 0);
1276 test_compare(MEMCACHED_SUCCESS
, rc
);
1279 // this should indicate end
1280 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1281 test_compare(MEMCACHED_END
, rc
);
1283 return TEST_SUCCESS
;
1286 /* Do not copy the style of this code, I just access hosts to testthis function */
1287 static test_return_t
stats_servername_test(memcached_st
*memc
)
1289 memcached_stat_st memc_stat
;
1290 memcached_server_instance_st instance
=
1291 memcached_server_instance_by_position(memc
, 0);
1293 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1295 return TEST_SKIPPED
;
1298 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1299 memcached_server_name(instance
),
1300 memcached_server_port(instance
)));
1302 return TEST_SUCCESS
;
1305 static test_return_t
increment_test(memcached_st
*memc
)
1307 uint64_t new_number
;
1309 test_compare(MEMCACHED_SUCCESS
,
1311 test_literal_param("number"),
1312 test_literal_param("0"),
1313 (time_t)0, (uint32_t)0));
1315 test_compare(MEMCACHED_SUCCESS
,
1316 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1317 test_compare(uint64_t(1), new_number
);
1319 test_compare(MEMCACHED_SUCCESS
,
1320 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1321 test_compare(uint64_t(2), new_number
);
1323 return TEST_SUCCESS
;
1326 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1328 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1330 uint64_t new_number
;
1331 uint64_t initial
= 0;
1333 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1335 test_compare(MEMCACHED_SUCCESS
,
1336 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1337 test_compare(new_number
, initial
);
1339 test_compare(MEMCACHED_SUCCESS
,
1340 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1341 test_compare(new_number
, (initial
+1));
1343 return TEST_SUCCESS
;
1346 static test_return_t
decrement_test(memcached_st
*memc
)
1348 uint64_t new_number
;
1349 memcached_return_t rc
;
1350 const char *value
= "3";
1352 rc
= memcached_set(memc
,
1353 test_literal_param("number"),
1354 value
, strlen(value
),
1355 (time_t)0, (uint32_t)0);
1356 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1358 test_compare(MEMCACHED_SUCCESS
,
1359 memcached_decrement(memc
,
1360 test_literal_param("number"),
1362 test_compare(uint64_t(2), new_number
);
1364 test_compare(MEMCACHED_SUCCESS
,
1365 memcached_decrement(memc
,
1366 test_literal_param("number"),
1368 test_compare(uint64_t(1), new_number
);
1370 return TEST_SUCCESS
;
1373 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1375 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1377 uint64_t new_number
;
1378 uint64_t initial
= 3;
1380 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1382 test_compare(MEMCACHED_SUCCESS
,
1383 memcached_decrement_with_initial(memc
,
1384 test_literal_param("number"),
1385 1, initial
, 0, &new_number
));
1386 test_compare(new_number
, initial
);
1388 test_compare(MEMCACHED_SUCCESS
,
1389 memcached_decrement_with_initial(memc
,
1390 test_literal_param("number"),
1391 1, initial
, 0, &new_number
));
1392 test_compare(new_number
, (initial
- 1));
1394 return TEST_SUCCESS
;
1397 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1399 uint64_t new_number
;
1400 memcached_return_t rc
;
1401 const char *master_key
= "foo";
1402 const char *key
= "number";
1403 const char *value
= "0";
1405 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1407 value
, strlen(value
),
1408 (time_t)0, (uint32_t)0);
1409 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1411 test_compare(MEMCACHED_SUCCESS
,
1412 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1413 test_compare(uint64_t(1), new_number
);
1415 test_compare(MEMCACHED_SUCCESS
,
1416 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1417 test_compare(uint64_t(2), new_number
);
1419 return TEST_SUCCESS
;
1422 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1424 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1426 uint64_t new_number
;
1427 memcached_return_t rc
;
1428 const char *master_key
= "foo";
1429 const char *key
= "number";
1430 uint64_t initial
= 0;
1432 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1434 1, initial
, 0, &new_number
);
1435 test_compare(MEMCACHED_SUCCESS
, rc
);
1436 test_compare(new_number
, initial
);
1438 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1440 1, initial
, 0, &new_number
);
1441 test_compare(MEMCACHED_SUCCESS
, rc
);
1442 test_compare(new_number
, (initial
+1));
1444 return TEST_SUCCESS
;
1447 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1449 uint64_t new_number
;
1450 memcached_return_t rc
;
1451 const char *value
= "3";
1453 rc
= memcached_set_by_key(memc
,
1454 test_literal_param("foo"),
1455 test_literal_param("number"),
1456 value
, strlen(value
),
1457 (time_t)0, (uint32_t)0);
1458 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1460 test_compare(MEMCACHED_SUCCESS
,
1461 memcached_decrement_by_key(memc
,
1462 test_literal_param("foo"),
1463 test_literal_param("number"),
1465 test_compare(uint64_t(2), new_number
);
1467 test_compare(MEMCACHED_SUCCESS
,
1468 memcached_decrement_by_key(memc
,
1469 test_literal_param("foo"),
1470 test_literal_param("number"),
1472 test_compare(uint64_t(1), new_number
);
1474 return TEST_SUCCESS
;
1477 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1479 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1481 uint64_t new_number
;
1482 uint64_t initial
= 3;
1484 test_compare(MEMCACHED_SUCCESS
,
1485 memcached_decrement_with_initial_by_key(memc
,
1486 test_literal_param("foo"),
1487 test_literal_param("number"),
1488 1, initial
, 0, &new_number
));
1489 test_compare(new_number
, initial
);
1491 test_compare(MEMCACHED_SUCCESS
,
1492 memcached_decrement_with_initial_by_key(memc
,
1493 test_literal_param("foo"),
1494 test_literal_param("number"),
1495 1, initial
, 0, &new_number
));
1496 test_compare(new_number
, (initial
- 1));
1498 return TEST_SUCCESS
;
1500 static test_return_t
binary_increment_with_prefix_test(memcached_st
*orig_memc
)
1502 memcached_st
*memc
= memcached_clone(NULL
, orig_memc
);
1504 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1506 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1508 memcached_return_t rc
;
1509 rc
= memcached_set(memc
,
1510 test_literal_param("number"),
1511 test_literal_param("0"),
1512 (time_t)0, (uint32_t)0);
1513 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1515 uint64_t new_number
;
1516 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1517 test_literal_param("number"),
1519 test_compare(uint64_t(1), new_number
);
1521 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1522 test_literal_param("number"),
1524 test_compare(uint64_t(2), new_number
);
1525 memcached_free(memc
);
1527 return TEST_SUCCESS
;
1530 static test_return_t
quit_test(memcached_st
*memc
)
1532 memcached_return_t rc
;
1533 const char *key
= "fudge";
1534 const char *value
= "sanford and sun";
1536 rc
= memcached_set(memc
, key
, strlen(key
),
1537 value
, strlen(value
),
1538 (time_t)10, (uint32_t)3);
1539 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1540 memcached_quit(memc
);
1542 rc
= memcached_set(memc
, key
, strlen(key
),
1543 value
, strlen(value
),
1544 (time_t)50, (uint32_t)9);
1545 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1547 return TEST_SUCCESS
;
1550 static test_return_t
mget_result_test(memcached_st
*memc
)
1552 const char *keys
[]= {"fudge", "son", "food"};
1553 size_t key_length
[]= {5, 3, 4};
1555 memcached_result_st results_obj
;
1556 memcached_result_st
*results
;
1558 results
= memcached_result_create(memc
, &results_obj
);
1560 test_true(&results_obj
== results
);
1562 /* We need to empty the server before continueing test */
1563 test_compare(MEMCACHED_SUCCESS
,
1564 memcached_flush(memc
, 0));
1566 test_compare(MEMCACHED_SUCCESS
,
1567 memcached_mget(memc
, keys
, key_length
, 3));
1569 memcached_return_t rc
;
1570 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1575 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1576 test_false(results
);
1577 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1579 for (uint32_t x
= 0; x
< 3; x
++)
1581 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1582 keys
[x
], key_length
[x
],
1583 (time_t)50, (uint32_t)9);
1584 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1587 test_compare(MEMCACHED_SUCCESS
,
1588 memcached_mget(memc
, keys
, key_length
, 3));
1590 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1593 test_true(&results_obj
== results
);
1594 test_compare(MEMCACHED_SUCCESS
, rc
);
1595 test_memcmp(memcached_result_key_value(results
),
1596 memcached_result_value(results
),
1597 memcached_result_length(results
));
1598 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1601 memcached_result_free(&results_obj
);
1603 return TEST_SUCCESS
;
1606 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1608 const char *keys
[]= {"fudge", "son", "food"};
1609 size_t key_length
[]= {5, 3, 4};
1611 memcached_result_st
*results
;
1613 /* We need to empty the server before continueing test */
1614 test_compare(MEMCACHED_SUCCESS
,
1615 memcached_flush(memc
, 0));
1617 test_compare(MEMCACHED_SUCCESS
,
1618 memcached_mget(memc
, keys
, key_length
, 3));
1620 memcached_return_t rc
;
1621 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1625 test_false(results
);
1626 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1628 for (uint32_t x
= 0; x
< 3; x
++)
1630 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1631 keys
[x
], key_length
[x
],
1632 (time_t)50, (uint32_t)9);
1633 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1636 test_compare(MEMCACHED_SUCCESS
,
1637 memcached_mget(memc
, keys
, key_length
, 3));
1640 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1643 test_compare(MEMCACHED_SUCCESS
, rc
);
1644 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1645 test_memcmp(memcached_result_key_value(results
),
1646 memcached_result_value(results
),
1647 memcached_result_length(results
));
1648 memcached_result_free(results
);
1652 return TEST_SUCCESS
;
1655 /* Count the results */
1656 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1658 size_t *counter
= (size_t *)context
;
1660 *counter
= *counter
+ 1;
1662 return MEMCACHED_SUCCESS
;
1665 static test_return_t
mget_result_function(memcached_st
*memc
)
1667 const char *keys
[]= {"fudge", "son", "food"};
1668 size_t key_length
[]= {5, 3, 4};
1670 memcached_execute_fn callbacks
[1];
1672 /* We need to empty the server before continueing test */
1673 test_compare(MEMCACHED_SUCCESS
,
1674 memcached_flush(memc
, 0));
1675 for (uint32_t x
= 0; x
< 3; x
++)
1677 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1678 keys
[x
], key_length
[x
],
1679 (time_t)50, (uint32_t)9);
1680 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1683 test_compare(MEMCACHED_SUCCESS
,
1684 memcached_mget(memc
, keys
, key_length
, 3));
1686 callbacks
[0]= &callback_counter
;
1689 test_compare(MEMCACHED_SUCCESS
,
1690 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1692 test_compare(size_t(3), counter
);
1694 return TEST_SUCCESS
;
1697 static test_return_t
mget_test(memcached_st
*memc
)
1699 const char *keys
[]= {"fudge", "son", "food"};
1700 size_t key_length
[]= {5, 3, 4};
1702 char return_key
[MEMCACHED_MAX_KEY
];
1703 size_t return_key_length
;
1705 size_t return_value_length
;
1707 /* We need to empty the server before continueing test */
1708 test_compare(MEMCACHED_SUCCESS
,
1709 memcached_flush(memc
, 0));
1711 test_compare(MEMCACHED_SUCCESS
,
1712 memcached_mget(memc
, keys
, key_length
, 3));
1715 memcached_return_t rc
;
1716 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1717 &return_value_length
, &flags
, &rc
)))
1719 test_true(return_value
);
1721 test_false(return_value
);
1722 test_zero(return_value_length
);
1723 test_compare(MEMCACHED_NOTFOUND
, rc
);
1725 for (uint32_t x
= 0; x
< 3; x
++)
1727 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1728 keys
[x
], key_length
[x
],
1729 (time_t)50, (uint32_t)9);
1730 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1732 test_compare(MEMCACHED_SUCCESS
,
1733 memcached_mget(memc
, keys
, key_length
, 3));
1736 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1737 &return_value_length
, &flags
, &rc
)))
1739 test_true(return_value
);
1740 test_compare(MEMCACHED_SUCCESS
, rc
);
1741 if (not memc
->_namespace
)
1743 test_compare(return_key_length
, return_value_length
);
1744 test_memcmp(return_value
, return_key
, return_value_length
);
1750 return TEST_SUCCESS
;
1753 static test_return_t
mget_execute(memcached_st
*memc
)
1757 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1761 * I only want to hit _one_ server so I know the number of requests I'm
1762 * sending in the pipeline.
1764 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1765 memc
->number_of_hosts
= 1;
1767 size_t max_keys
= 20480;
1770 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1771 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1773 /* First add all of the items.. */
1774 char blob
[1024] = {0};
1775 memcached_return_t rc
;
1777 for (size_t x
= 0; x
< max_keys
; ++x
)
1781 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1783 test_true(keys
[x
] != NULL
);
1784 uint64_t query_id
= memcached_query_id(memc
);
1785 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1786 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1787 test_compare(query_id
+1, memcached_query_id(memc
));
1790 /* Try to get all of them with a large multiget */
1792 memcached_execute_fn callbacks
[]= { &callback_counter
};
1793 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1794 max_keys
, callbacks
, &counter
, 1);
1796 if (memcached_success(rc
))
1799 uint64_t query_id
= memcached_query_id(memc
);
1800 test_compare(MEMCACHED_SUCCESS
,
1801 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1802 test_compare(query_id
, memcached_query_id(memc
));
1804 /* Verify that we got all of the items */
1805 test_true(counter
== max_keys
);
1807 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1809 test_true(counter
== 0);
1813 test_fail("note: this test functions differently when in binary mode");
1816 /* Release all allocated resources */
1817 for (size_t x
= 0; x
< max_keys
; ++x
)
1824 memc
->number_of_hosts
= number_of_hosts
;
1825 return TEST_SUCCESS
;
1828 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1830 static test_return_t
key_setup(memcached_st
*memc
)
1832 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1834 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1836 return TEST_SUCCESS
;
1839 static test_return_t
key_teardown(memcached_st
*memc
)
1842 pairs_free(global_pairs
);
1844 return TEST_SUCCESS
;
1847 static test_return_t
block_add_regression(memcached_st
*memc
)
1849 /* First add all of the items.. */
1850 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1852 memcached_return_t rc
;
1853 char blob
[1024] = {0};
1855 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1856 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1859 return TEST_SUCCESS
;
1862 static test_return_t
binary_add_regression(memcached_st
*memc
)
1864 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1865 test_return_t rc
= block_add_regression(memc
);
1866 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1870 static test_return_t
get_stats_keys(memcached_st
*memc
)
1874 memcached_stat_st memc_stat
;
1875 memcached_return_t rc
;
1877 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1878 test_compare(MEMCACHED_SUCCESS
, rc
);
1879 for (ptr
= stat_list
; *ptr
; ptr
++)
1884 return TEST_SUCCESS
;
1887 static test_return_t
version_string_test(memcached_st
*memc
)
1889 const char *version_string
;
1892 version_string
= memcached_lib_version();
1894 test_strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
);
1896 return TEST_SUCCESS
;
1899 static test_return_t
get_stats(memcached_st
*memc
)
1901 memcached_return_t rc
;
1903 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1904 test_compare(MEMCACHED_SUCCESS
, rc
);
1905 test_true(memc_stat
);
1907 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1909 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1910 test_compare(MEMCACHED_SUCCESS
, rc
);
1911 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1916 memcached_stat_free(NULL
, memc_stat
);
1918 return TEST_SUCCESS
;
1921 static test_return_t
add_host_test(memcached_st
*memc
)
1924 memcached_server_st
*servers
;
1925 memcached_return_t rc
;
1926 char servername
[]= "0.example.com";
1928 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1930 test_true(1 == memcached_server_list_count(servers
));
1932 for (x
= 2; x
< 20; x
++)
1934 char buffer
[SMALL_STRING_LEN
];
1936 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1937 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1939 test_compare(MEMCACHED_SUCCESS
, rc
);
1940 test_true(x
== memcached_server_list_count(servers
));
1943 rc
= memcached_server_push(memc
, servers
);
1944 test_compare(MEMCACHED_SUCCESS
, rc
);
1945 rc
= memcached_server_push(memc
, servers
);
1946 test_compare(MEMCACHED_SUCCESS
, rc
);
1948 memcached_server_list_free(servers
);
1950 return TEST_SUCCESS
;
1953 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1955 memcached_return_t rc
;
1956 const char *key
= "not_found";
1957 size_t key_len
= strlen(key
);
1959 test_compare(MEMCACHED_SUCCESS
,
1960 memcached_mget(memc
, &key
, &key_len
, 1));
1962 memcached_result_st
*result
= NULL
;
1963 result
= memcached_fetch_result(memc
, result
, &rc
);
1965 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1967 memcached_result_free(result
);
1969 return TEST_SUCCESS
;
1972 static memcached_return_t
clone_test_callback(memcached_st
*parent
, memcached_st
*memc_clone
)
1974 (void)parent
;(void)memc_clone
;
1975 return MEMCACHED_SUCCESS
;
1978 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
)
1981 return MEMCACHED_SUCCESS
;
1984 static test_return_t
callback_test(memcached_st
*memc
)
1986 /* Test User Data */
1990 memcached_return_t rc
;
1992 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1993 test_compare(MEMCACHED_SUCCESS
, rc
);
1994 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1995 test_true(*test_ptr
== x
);
1998 /* Test Clone Callback */
2000 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2001 void *clone_cb_ptr
= *(void **)&clone_cb
;
2002 void *temp_function
= NULL
;
2003 memcached_return_t rc
;
2005 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2007 test_compare(MEMCACHED_SUCCESS
, rc
);
2008 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2009 test_true(temp_function
== clone_cb_ptr
);
2012 /* Test Cleanup Callback */
2014 memcached_cleanup_fn cleanup_cb
=
2015 (memcached_cleanup_fn
)cleanup_test_callback
;
2016 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2017 void *temp_function
= NULL
;
2018 memcached_return_t rc
;
2020 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2022 test_compare(MEMCACHED_SUCCESS
, rc
);
2023 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2024 test_true(temp_function
== cleanup_cb_ptr
);
2027 return TEST_SUCCESS
;
2030 /* We don't test the behavior itself, we test the switches */
2031 static test_return_t
behavior_test(memcached_st
*memc
)
2036 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2037 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2038 test_true(value
== 1);
2040 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2041 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2042 test_true(value
== 1);
2044 set
= MEMCACHED_HASH_MD5
;
2045 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2046 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2047 test_true(value
== MEMCACHED_HASH_MD5
);
2051 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2052 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2053 test_true(value
== 0);
2055 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2056 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2057 test_true(value
== 0);
2059 set
= MEMCACHED_HASH_DEFAULT
;
2060 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2061 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2062 test_true(value
== MEMCACHED_HASH_DEFAULT
);
2064 set
= MEMCACHED_HASH_CRC
;
2065 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2066 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2067 test_true(value
== MEMCACHED_HASH_CRC
);
2069 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2070 test_true(value
> 0);
2072 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2073 test_true(value
> 0);
2075 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2076 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
2077 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2079 return TEST_SUCCESS
;
2082 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2084 memcached_return_t rc
;
2087 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
2088 test_true(rc
== MEMCACHED_DEPRECATED
);
2090 // Platform dependent
2092 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2096 return TEST_SUCCESS
;
2100 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2102 memcached_return_t rc
;
2106 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, set
);
2107 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2109 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2111 if (rc
== MEMCACHED_SUCCESS
)
2113 test_true((bool)value
== set
);
2117 test_false((bool)value
== set
);
2120 return TEST_SUCCESS
;
2124 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2126 memcached_return_t rc
;
2130 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, set
);
2131 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2133 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2135 if (rc
== MEMCACHED_SUCCESS
)
2137 test_true((bool)value
== set
);
2141 test_false((bool)value
== set
);
2144 return TEST_SUCCESS
;
2147 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, const memcached_return_t expect
)
2149 memcached_return_t rc
;
2150 char return_key
[MEMCACHED_MAX_KEY
];
2151 size_t return_key_length
;
2153 size_t return_value_length
;
2157 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2158 &return_value_length
, &flags
, &rc
)))
2160 test_true(return_value
);
2161 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2166 if (memcached_success(expect
) and memcached_success(rc
))
2168 return TEST_SUCCESS
;
2170 else if (expect
== rc
)
2172 return TEST_SUCCESS
;
2174 fprintf(stderr
, "\n%s:%u %s(#%u)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), keys_returned
);
2176 return TEST_FAILURE
;
2179 /* Test case provided by Cal Haldenbrand */
2180 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2181 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2182 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2184 /* We just keep looking at the same values over and over */
2187 unsigned int setter
= 1;
2188 test_compare(MEMCACHED_SUCCESS
,
2189 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2190 test_compare(MEMCACHED_SUCCESS
,
2191 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2195 unsigned long long total
= 0;
2196 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2198 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2199 char randomstuff
[6 * 1024];
2200 memset(randomstuff
, 0, 6 * 1024);
2201 test_true(size
< 6 * 1024); /* Being safe here */
2203 for (uint32_t j
= 0 ; j
< size
;j
++)
2205 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2210 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2211 test_compare(MEMCACHED_SUCCESS
,
2212 memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
));
2214 test_true(total
> HALDENBRAND_KEY_COUNT
);
2216 return TEST_SUCCESS
;
2219 /* Test case provided by Cal Haldenbrand */
2220 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2222 unsigned int setter
= 1;
2224 test_compare(MEMCACHED_SUCCESS
,
2225 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2227 test_compare(MEMCACHED_SUCCESS
,
2228 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2231 setter
= 20 * 1024576;
2232 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2233 setter
= 20 * 1024576;
2234 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2235 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2236 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2238 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2241 size_t total_value_length
= 0;
2242 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2247 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2248 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2250 memcached_return_t rc
;
2251 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2252 if (memcached_failed(rc
))
2254 if (rc
== MEMCACHED_NOTFOUND
)
2265 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2267 total_value_length
+= val_len
;
2272 return TEST_SUCCESS
;
2275 /* Do a large mget() over all the keys we think exist */
2276 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2278 unsigned int setter
= 1;
2279 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2280 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2282 setter
= 20 * 1024576;
2283 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2284 setter
= 20 * 1024576;
2285 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2286 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2287 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2290 size_t key_lengths
[HALDENBRAND_KEY_COUNT
];
2291 char **keys
= static_cast<char **>(calloc(HALDENBRAND_KEY_COUNT
, sizeof(char *)));
2293 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2295 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2296 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2297 keys
[x
]= strdup(key
);
2299 key_lengths
[x
]= key_length
;
2300 test_compare(size_t(key_length
), strlen(keys
[x
]));
2303 test_compare(MEMCACHED_SUCCESS
,
2304 memcached_mget(memc
, (const char **)keys
, key_lengths
, HALDENBRAND_KEY_COUNT
));
2306 unsigned int keys_returned
;
2307 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
2308 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2310 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2316 return TEST_SUCCESS
;
2319 /* Make sure we behave properly if server list has no values */
2320 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2322 const char *keys
[]= {"fudge", "son", "food"};
2323 size_t key_length
[]= {5, 3, 4};
2325 /* Here we free everything before running a bunch of mget tests */
2326 memcached_servers_reset(memc
);
2329 /* We need to empty the server before continueing test */
2330 test_compare(MEMCACHED_NO_SERVERS
,
2331 memcached_flush(memc
, 0));
2333 test_compare(MEMCACHED_NO_SERVERS
,
2334 memcached_mget(memc
, keys
, key_length
, 3));
2336 unsigned int keys_returned
;
2337 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2338 test_zero(keys_returned
);
2340 for (uint32_t x
= 0; x
< 3; x
++)
2342 test_compare(MEMCACHED_NO_SERVERS
,
2343 memcached_set(memc
, keys
[x
], key_length
[x
],
2344 keys
[x
], key_length
[x
],
2345 (time_t)50, (uint32_t)9));
2348 test_compare(MEMCACHED_NO_SERVERS
,
2349 memcached_mget(memc
, keys
, key_length
, 3));
2353 char return_key
[MEMCACHED_MAX_KEY
];
2354 memcached_return_t rc
;
2355 size_t return_key_length
;
2356 size_t return_value_length
;
2359 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2360 &return_value_length
, &flags
, &rc
)))
2362 test_true(return_value
);
2363 test_compare(MEMCACHED_SUCCESS
, rc
);
2364 test_true(return_key_length
== return_value_length
);
2365 test_memcmp(return_value
, return_key
, return_value_length
);
2371 return TEST_SUCCESS
;
2374 #define VALUE_SIZE_BUG5 1048064
2375 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2377 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2378 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2380 size_t value_length
;
2382 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2384 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2386 insert_data
[x
]= (signed char)rand();
2389 test_compare(MEMCACHED_SUCCESS
,
2390 memcached_flush(memc
, 0));
2392 memcached_return_t rc
;
2393 value
= memcached_get(memc
, keys
[0], key_length
[0],
2394 &value_length
, &flags
, &rc
);
2396 test_compare(MEMCACHED_SUCCESS
,
2397 memcached_mget(memc
, keys
, key_length
, 4));
2400 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2403 for (uint32_t x
= 0; x
< 4; x
++)
2405 test_compare(MEMCACHED_SUCCESS
,
2406 memcached_set(memc
, keys
[x
], key_length
[x
],
2407 insert_data
, VALUE_SIZE_BUG5
,
2408 (time_t)0, (uint32_t)0));
2411 for (uint32_t x
= 0; x
< 10; x
++)
2413 value
= memcached_get(memc
, keys
[0], key_length
[0],
2414 &value_length
, &flags
, &rc
);
2415 test_compare(rc
, MEMCACHED_SUCCESS
);
2419 test_compare(MEMCACHED_SUCCESS
,
2420 memcached_mget(memc
, keys
, key_length
, 4));
2422 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2423 test_compare(4U, count
);
2425 delete [] insert_data
;
2427 return TEST_SUCCESS
;
2430 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2432 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2433 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2434 char return_key
[MEMCACHED_MAX_KEY
];
2435 size_t return_key_length
;
2437 size_t value_length
;
2439 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2441 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2443 insert_data
[x
]= (signed char)rand();
2446 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2448 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2450 // We will now confirm that memcached_mget() returns success, but we will
2451 // then check to make sure that no actual keys are returned.
2452 test_compare(MEMCACHED_SUCCESS
,
2453 memcached_mget(memc
, keys
, key_length
, 4));
2455 memcached_return_t rc
;
2457 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2458 &value_length
, &flags
, &rc
)))
2463 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2465 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2467 test_compare(MEMCACHED_SUCCESS
,
2468 memcached_set(memc
, keys
[x
], key_length
[x
],
2469 insert_data
, VALUE_SIZE_BUG5
,
2470 (time_t)0, (uint32_t)0));
2472 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2474 for (uint32_t x
= 0; x
< 2; x
++)
2476 value
= memcached_get(memc
, keys
[0], key_length
[0],
2477 &value_length
, &flags
, &rc
);
2481 test_compare(MEMCACHED_SUCCESS
,
2482 memcached_mget(memc
, keys
, key_length
, 4));
2483 /* We test for purge of partial complete fetches */
2484 for (count
= 3; count
; count
--)
2486 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2487 &value_length
, &flags
, &rc
);
2488 test_compare(MEMCACHED_SUCCESS
, rc
);
2489 test_memcmp(value
, insert_data
, value_length
);
2490 test_true(value_length
);
2494 delete [] insert_data
;
2496 return TEST_SUCCESS
;
2499 static test_return_t
user_supplied_bug8(memcached_st
*)
2501 memcached_return_t rc
;
2503 memcached_st
*memc_clone
;
2505 memcached_server_st
*servers
;
2506 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";
2508 servers
= memcached_servers_parse(server_list
);
2511 mine
= memcached_create(NULL
);
2512 rc
= memcached_server_push(mine
, servers
);
2513 test_compare(MEMCACHED_SUCCESS
, rc
);
2514 memcached_server_list_free(servers
);
2517 memc_clone
= memcached_clone(NULL
, mine
);
2519 memcached_quit(mine
);
2520 memcached_quit(memc_clone
);
2523 memcached_free(mine
);
2524 memcached_free(memc_clone
);
2526 return TEST_SUCCESS
;
2529 /* Test flag store/retrieve */
2530 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2532 const char *keys
= "036790384900";
2533 size_t key_length
= strlen(keys
);
2534 char return_key
[MEMCACHED_MAX_KEY
];
2535 size_t return_key_length
;
2537 size_t value_length
;
2539 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2541 for (unsigned int x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2542 insert_data
[x
]= (signed char)rand();
2544 memcached_flush(memc
, 0);
2547 memcached_return_t rc
= memcached_set(memc
, keys
, key_length
,
2548 insert_data
, VALUE_SIZE_BUG5
,
2550 test_compare(MEMCACHED_SUCCESS
, rc
);
2553 value
= memcached_get(memc
, keys
, key_length
,
2554 &value_length
, &flags
, &rc
);
2555 test_true(flags
== 245);
2559 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2562 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2563 &value_length
, &flags
, &rc
);
2564 test_compare(uint32_t(245), flags
);
2567 delete [] insert_data
;
2570 return TEST_SUCCESS
;
2573 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2575 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2576 size_t key_length
[3];
2580 char return_key
[MEMCACHED_MAX_KEY
];
2581 size_t return_key_length
;
2583 size_t return_value_length
;
2586 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2587 key_length
[1]= strlen("fudge&*@#");
2588 key_length
[2]= strlen("for^#@&$not");
2591 for (unsigned int x
= 0; x
< 3; x
++)
2593 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2594 keys
[x
], key_length
[x
],
2595 (time_t)50, (uint32_t)9);
2596 test_compare(MEMCACHED_SUCCESS
, rc
);
2599 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2600 test_compare(MEMCACHED_SUCCESS
, rc
);
2602 /* We need to empty the server before continueing test */
2603 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2604 &return_value_length
, &flags
, &rc
)) != NULL
)
2606 test_true(return_value
);
2610 test_compare(3U, count
);
2612 return TEST_SUCCESS
;
2615 /* We are testing with aggressive timeout to get failures */
2616 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2618 size_t value_length
= 512;
2619 unsigned int set
= 1;
2620 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2622 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2623 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2624 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2626 char *value
= (char*)malloc(value_length
* sizeof(char));
2628 for (unsigned int x
= 0; x
< value_length
; x
++)
2630 value
[x
]= (char) (x
% 127);
2633 for (unsigned int x
= 1; x
<= 100000; ++x
)
2635 memcached_return_t rc
= memcached_set(mclone
,
2636 test_literal_param("foo"),
2637 value
, value_length
, 0, 0);
2639 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2640 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2641 memcached_strerror(NULL
, rc
));
2643 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2650 memcached_free(mclone
);
2652 return TEST_SUCCESS
;
2656 We are looking failures in the async protocol
2658 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2660 const char *key
= "foo";
2661 size_t value_length
= 512;
2663 unsigned int set
= 1;
2664 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2666 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2667 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2668 int32_t timeout
= -1;
2669 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, (size_t)timeout
);
2671 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2673 test_true(timeout
== -1);
2675 char *value
= (char*)malloc(value_length
* sizeof(char));
2677 for (unsigned int x
= 0; x
< value_length
; x
++)
2679 value
[x
]= (char) (x
% 127);
2682 for (unsigned int x
= 1; x
<= 100000; ++x
)
2684 memcached_return_t rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2689 memcached_free(mclone
);
2691 return TEST_SUCCESS
;
2695 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2697 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2699 memcached_return_t rc
;
2701 size_t value_length
;
2703 uint64_t number_value
;
2705 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2706 &value_length
, &flags
, &rc
);
2707 test_true(value
== NULL
);
2708 test_compare(MEMCACHED_NOTFOUND
, rc
);
2710 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2713 test_true(value
== NULL
);
2714 /* The binary protocol will set the key if it doesn't exist */
2715 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2717 test_compare(MEMCACHED_SUCCESS
, rc
);
2721 test_compare(MEMCACHED_NOTFOUND
, rc
);
2724 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2726 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2727 &value_length
, &flags
, &rc
);
2729 test_compare(MEMCACHED_SUCCESS
, rc
);
2732 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2734 test_true(number_value
== 2);
2735 test_compare(MEMCACHED_SUCCESS
, rc
);
2737 return TEST_SUCCESS
;
2741 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2742 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2744 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2746 char key
[] = "key34567890";
2747 memcached_return_t rc
;
2748 size_t overflowSize
;
2750 char commandFirst
[]= "set key34567890 0 0 ";
2751 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2752 size_t commandLength
;
2755 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2757 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2759 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2761 char *overflow
= new (std::nothrow
) char[testSize
];
2762 test_true(overflow
);
2764 memset(overflow
, 'x', testSize
);
2765 rc
= memcached_set(memc
, key
, strlen(key
),
2766 overflow
, testSize
, 0, 0);
2767 test_compare(MEMCACHED_SUCCESS
, rc
);
2771 return TEST_SUCCESS
;
2776 Test values of many different sizes
2777 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2778 set key34567890 0 0 8169 \r\n
2779 is sent followed by buffer of size 8169, followed by 8169
2781 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2783 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2785 std::vector
<char> value
;
2786 for (size_t x
= 0; x
< 18000; x
++)
2788 value
.push_back((char) (x
% 127));
2791 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2793 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2794 &value
[0], current_length
,
2795 (time_t)0, (uint32_t)0);
2796 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2798 size_t string_length
;
2800 char *string
= memcached_get(memc
, test_literal_param("foo"),
2801 &string_length
, &flags
, &rc
);
2803 test_compare(MEMCACHED_SUCCESS
, rc
);
2804 test_compare(string_length
, current_length
);
2805 test_memcmp(string
, &value
[0], string_length
);
2810 return TEST_SUCCESS
;
2814 Look for zero length value problems
2816 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2818 for (uint32_t x
= 0; x
< 2; x
++)
2820 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2822 (time_t)0, (uint32_t)0);
2824 test_compare(MEMCACHED_SUCCESS
, rc
);
2828 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2829 &length
, &flags
, &rc
);
2831 test_compare(MEMCACHED_SUCCESS
, rc
);
2836 value
= memcached_get(memc
, test_literal_param("mykey"),
2837 &length
, &flags
, &rc
);
2839 test_compare(MEMCACHED_SUCCESS
, rc
);
2840 test_true(value
== NULL
);
2845 return TEST_SUCCESS
;
2848 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2849 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2851 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2853 (time_t)0, UINT32_MAX
);
2855 test_compare(MEMCACHED_SUCCESS
, rc
);
2859 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2860 &length
, &flags
, &rc
);
2862 test_compare(MEMCACHED_SUCCESS
, rc
);
2863 test_true(value
== NULL
);
2865 test_compare(flags
, UINT32_MAX
);
2867 return TEST_SUCCESS
;
2870 #if !defined(__sun) && !defined(__OpenBSD__)
2871 /* Check the validity of chinese key*/
2872 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2874 const char *key
= "豆瓣";
2875 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2876 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2877 value
, strlen(value
),
2880 test_compare(MEMCACHED_SUCCESS
, rc
);
2884 char *value2
= memcached_get(memc
, key
, strlen(key
),
2885 &length
, &flags
, &rc
);
2887 test_true(length
==strlen(value
));
2888 test_compare(MEMCACHED_SUCCESS
, rc
);
2889 test_memcmp(value
, value2
, length
);
2892 return TEST_SUCCESS
;
2900 static test_return_t
user_supplied_bug19(memcached_st
*)
2902 memcached_return_t res
;
2904 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2906 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2909 memcached_free(memc
);
2911 return TEST_SUCCESS
;
2914 /* CAS test from Andei */
2915 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2917 const char *key
= "abc";
2918 size_t key_len
= strlen("abc");
2920 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2922 test_compare(MEMCACHED_SUCCESS
,
2924 test_literal_param("abc"),
2925 test_literal_param("foobar"),
2926 (time_t)0, (uint32_t)0));
2928 test_compare(MEMCACHED_SUCCESS
,
2929 memcached_mget(memc
, &key
, &key_len
, 1));
2931 memcached_result_st result_obj
;
2932 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2935 memcached_result_create(memc
, &result_obj
);
2936 memcached_return_t status
;
2937 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2940 test_compare(MEMCACHED_SUCCESS
, status
);
2942 memcached_result_free(result
);
2944 return TEST_SUCCESS
;
2947 /* Large mget() of missing keys with binary proto
2949 * If many binary quiet commands (such as getq's in an mget) fill the output
2950 * buffer and the server chooses not to respond, memcached_flush hangs. See
2951 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2954 /* sighandler_t function that always asserts false */
2955 static void fail(int)
2961 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2966 return TEST_SKIPPED
;
2968 void (*oldalarm
)(int);
2970 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2971 test_true(memc_clone
);
2973 /* only binproto uses getq for mget */
2974 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2976 /* empty the cache to ensure misses (hence non-responses) */
2977 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2979 size_t* key_lengths
= new (std::nothrow
) size_t[key_count
];
2980 test_true(key_lengths
);
2981 char **keys
= static_cast<char **>(calloc(key_count
, sizeof(char *)));
2983 for (unsigned int x
= 0; x
< key_count
; x
++)
2987 snprintf(buffer
, 30, "%u", x
);
2988 keys
[x
]= strdup(buffer
);
2990 key_lengths
[x
]= strlen(keys
[x
]);
2993 oldalarm
= signal(SIGALRM
, fail
);
2996 test_compare_got(MEMCACHED_SUCCESS
,
2997 memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
), memcached_last_error_message(memc_clone
));
3000 signal(SIGALRM
, oldalarm
);
3002 memcached_return_t rc
;
3004 char return_key
[MEMCACHED_MAX_KEY
];
3005 size_t return_key_length
;
3007 size_t return_value_length
;
3008 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
3009 &return_value_length
, &flags
, &rc
)))
3011 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
3013 test_compare(MEMCACHED_NOTFOUND
, rc
);
3014 test_zero(return_value_length
);
3015 test_zero(return_key_length
);
3016 test_false(return_key
[0]);
3017 test_false(return_value
);
3019 for (unsigned int x
= 0; x
< key_count
; x
++)
3024 delete [] key_lengths
;
3026 memcached_free(memc_clone
);
3028 return TEST_SUCCESS
;
3032 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3034 test_return_t test_rc
;
3035 test_rc
= pre_binary(memc
);
3037 if (test_rc
!= TEST_SUCCESS
)
3042 /* should work as of r580 */
3043 test_compare(TEST_SUCCESS
,
3044 _user_supplied_bug21(memc
, 10));
3046 /* should fail as of r580 */
3047 test_compare(TEST_SUCCESS
,
3048 _user_supplied_bug21(memc
, 1000));
3050 return TEST_SUCCESS
;
3053 static test_return_t
output_ketama_weighted_keys(memcached_st
*)
3055 memcached_st
*memc
= memcached_create(NULL
);
3059 test_compare(MEMCACHED_SUCCESS
,
3060 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
3062 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3063 test_compare(value
, uint64_t(1));
3065 test_compare(MEMCACHED_SUCCESS
,
3066 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3068 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3069 test_true(value
== MEMCACHED_HASH_MD5
);
3072 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3074 memcached_server_st
*server_pool
;
3075 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");
3076 memcached_server_push(memc
, server_pool
);
3078 // @todo this needs to be refactored to actually test something.
3081 if ((fp
= fopen("ketama_keys.txt", "w")))
3085 printf("cannot write to file ketama_keys.txt");
3086 return TEST_FAILURE
;
3089 for (int x
= 0; x
< 10000; x
++)
3092 snprintf(key
, sizeof(key
), "%d", x
);
3094 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3095 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3096 in_port_t port
= memc
->hosts
[server_idx
].port
;
3097 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3098 memcached_server_instance_st instance
=
3099 memcached_server_instance_by_position(memc
, host_index
);
3103 memcached_server_list_free(server_pool
);
3104 memcached_free(memc
);
3106 return TEST_SUCCESS
;
3110 static test_return_t
result_static(memcached_st
*memc
)
3112 memcached_result_st result
;
3113 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3114 test_false(result
.options
.is_allocated
);
3115 test_true(memcached_is_initialized(&result
));
3116 test_true(result_ptr
);
3117 test_true(result_ptr
== &result
);
3119 memcached_result_free(&result
);
3121 test_false(result
.options
.is_allocated
);
3122 test_false(memcached_is_initialized(&result
));
3124 return TEST_SUCCESS
;
3127 static test_return_t
result_alloc(memcached_st
*memc
)
3129 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3130 test_true(result_ptr
);
3131 test_true(result_ptr
->options
.is_allocated
);
3132 test_true(memcached_is_initialized(result_ptr
));
3133 memcached_result_free(result_ptr
);
3135 return TEST_SUCCESS
;
3138 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3141 pairs_free(global_pairs
);
3143 return TEST_SUCCESS
;
3146 static test_return_t
generate_pairs(memcached_st
*)
3148 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3149 global_count
= GLOBAL_COUNT
;
3151 for (size_t x
= 0; x
< global_count
; x
++)
3153 global_keys
[x
]= global_pairs
[x
].key
;
3154 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3157 return TEST_SUCCESS
;
3160 static test_return_t
generate_large_pairs(memcached_st
*)
3162 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3163 global_count
= GLOBAL2_COUNT
;
3165 for (size_t x
= 0; x
< global_count
; x
++)
3167 global_keys
[x
]= global_pairs
[x
].key
;
3168 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3171 return TEST_SUCCESS
;
3174 static test_return_t
generate_data(memcached_st
*memc
)
3176 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3178 test_compare(check_execute
, global_count
);
3180 return TEST_SUCCESS
;
3183 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3185 uint32_t host_index
= 0;
3186 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3188 test_true(check_execute
== global_count
);
3190 // @todo hosts used size stats
3191 memcached_return_t rc
;
3192 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3195 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3197 /* This test was changes so that "make test" would work properlly */
3200 memcached_server_instance_st instance
=
3201 memcached_server_instance_by_position(memc
, host_index
);
3203 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3205 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3208 memcached_stat_free(NULL
, stat_p
);
3210 return TEST_SUCCESS
;
3212 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3214 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3215 generate_data(memc
);
3217 return TEST_SUCCESS
;
3220 static test_return_t
get_read_count(memcached_st
*memc
)
3222 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3223 test_true(memc_clone
);
3225 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3229 size_t return_value_length
;
3233 for (size_t x
= count
= 0; x
< global_count
; x
++)
3235 memcached_return_t rc
;
3236 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3237 &return_value_length
, &flags
, &rc
);
3238 if (rc
== MEMCACHED_SUCCESS
)
3249 memcached_free(memc_clone
);
3251 return TEST_SUCCESS
;
3254 static test_return_t
get_read(memcached_st
*memc
)
3256 for (size_t x
= 0; x
< global_count
; x
++)
3258 size_t return_value_length
;
3260 memcached_return_t rc
;
3261 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3262 &return_value_length
, &flags
, &rc
);
3264 test_true(return_value);
3265 test_compare(MEMCACHED_SUCCESS, rc);
3267 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3273 return TEST_SUCCESS
;
3276 static test_return_t
mget_read(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 // Go fetch the keys and test to see if all of them were returned
3286 unsigned int keys_returned
;
3287 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3288 test_true(keys_returned
> 0);
3289 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3292 return TEST_SUCCESS
;
3295 static test_return_t
mget_read_result(memcached_st
*memc
)
3298 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3300 test_compare(MEMCACHED_SUCCESS
,
3301 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3303 /* Turn this into a help function */
3305 memcached_result_st results_obj
;
3306 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3308 memcached_return_t rc
;
3309 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3311 if (rc
== MEMCACHED_IN_PROGRESS
)
3317 test_compare(MEMCACHED_SUCCESS
, rc
);
3319 test_compare(MEMCACHED_END
, rc
);
3321 memcached_result_free(&results_obj
);
3324 return TEST_SUCCESS
;
3327 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3330 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3332 test_compare(MEMCACHED_SUCCESS
,
3333 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3335 memcached_result_st
*results
= NULL
;
3336 memcached_return_t rc
;
3337 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3340 test_compare(MEMCACHED_SUCCESS
, rc
);
3342 test_compare(MEMCACHED_END
, rc
);
3344 memcached_result_free(results
);
3347 return TEST_SUCCESS
;
3350 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3353 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3355 test_compare(MEMCACHED_SUCCESS
,
3356 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3358 // We will scan for just one key
3360 memcached_result_st results_obj
;
3361 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3363 memcached_return_t rc
;
3364 results
= memcached_fetch_result(memc
, results
, &rc
);
3366 test_compare(MEMCACHED_SUCCESS
, rc
);
3368 memcached_result_free(&results_obj
);
3371 // We already have a read happening, lets start up another one.
3372 test_compare(MEMCACHED_SUCCESS
,
3373 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3375 memcached_result_st results_obj
;
3376 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3378 memcached_return_t rc
;
3379 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3382 test_compare(MEMCACHED_SUCCESS
, rc
);
3384 test_compare(MEMCACHED_END
, rc
);
3386 memcached_result_free(&results_obj
);
3389 return TEST_SUCCESS
;
3392 static test_return_t
mget_read_function(memcached_st
*memc
)
3394 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3396 test_compare(MEMCACHED_SUCCESS
,
3397 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3399 memcached_execute_fn callbacks
[]= { &callback_counter
};
3401 test_compare(MEMCACHED_SUCCESS
,
3402 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3404 return TEST_SUCCESS
;
3407 static test_return_t
delete_generate(memcached_st
*memc
)
3409 for (size_t x
= 0; x
< global_count
; x
++)
3411 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3414 return TEST_SUCCESS
;
3417 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3419 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3421 for (size_t x
= 0; x
< global_count
; x
++)
3423 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3426 return TEST_SUCCESS
;
3429 static test_return_t
add_host_test1(memcached_st
*memc
)
3431 memcached_return_t rc
;
3432 char servername
[]= "0.example.com";
3434 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3436 test_compare(1U, memcached_server_list_count(servers
));
3438 for (uint32_t x
= 2; x
< 20; x
++)
3440 char buffer
[SMALL_STRING_LEN
];
3442 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3443 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3445 test_compare(MEMCACHED_SUCCESS
, rc
);
3446 test_compare(x
, memcached_server_list_count(servers
));
3449 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3450 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3452 memcached_server_list_free(servers
);
3454 return TEST_SUCCESS
;
3457 static test_return_t
pre_nonblock(memcached_st
*memc
)
3459 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3461 return TEST_SUCCESS
;
3464 static test_return_t
pre_cork(memcached_st
*memc
)
3467 return TEST_SKIPPED
;
3470 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3471 return TEST_SUCCESS
;
3473 return TEST_SKIPPED
;
3476 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3479 return TEST_SKIPPED
;
3481 test_return_t test_rc
;
3482 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3485 return pre_nonblock(memc
);
3488 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3490 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3491 test_true(memc_clone
);
3493 // The memcached_version needs to be done on a clone, because the server
3494 // will not toggle protocol on an connection.
3495 memcached_version(memc_clone
);
3497 memcached_return_t rc
= MEMCACHED_FAILURE
;
3498 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3500 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3501 test_compare(MEMCACHED_SUCCESS
,
3502 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3503 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3507 memcached_free(memc_clone
);
3508 return TEST_SKIPPED
;
3511 memcached_free(memc_clone
);
3513 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3516 static test_return_t
pre_murmur(memcached_st
*memc
)
3518 #ifdef HAVE_MURMUR_HASH
3519 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3520 return TEST_SUCCESS
;
3523 return TEST_SKIPPED
;
3527 static test_return_t
pre_jenkins(memcached_st
*memc
)
3529 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3531 return TEST_SUCCESS
;
3535 static test_return_t
pre_md5(memcached_st
*memc
)
3537 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3539 return TEST_SUCCESS
;
3542 static test_return_t
pre_crc(memcached_st
*memc
)
3544 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3546 return TEST_SUCCESS
;
3549 static test_return_t
pre_hsieh(memcached_st
*memc
)
3551 #ifdef HAVE_HSIEH_HASH
3552 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3553 return TEST_SUCCESS
;
3556 return TEST_SKIPPED
;
3560 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3562 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3564 return TEST_SUCCESS
;
3567 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3569 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3571 return TEST_SUCCESS
;
3574 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3576 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3578 return TEST_SUCCESS
;
3581 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3583 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3585 return TEST_SUCCESS
;
3588 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3590 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3591 test_compare(MEMCACHED_SUCCESS
, rc
);
3593 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3594 test_compare(value
, uint64_t(1));
3596 return TEST_SUCCESS
;
3599 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3601 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3602 test_compare(MEMCACHED_SUCCESS
, rc
);
3604 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3605 test_compare(value
, uint64_t(1));
3607 test_compare(MEMCACHED_SUCCESS
,
3608 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3610 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3611 test_compare(MEMCACHED_HASH_MD5
, memcached_hash_t(value
));
3613 return TEST_SUCCESS
;
3617 @note This should be testing to see if the server really supports the binary protocol.
3619 static test_return_t
pre_binary(memcached_st
*memc
)
3621 memcached_return_t rc
= MEMCACHED_FAILURE
;
3623 if (libmemcached_util_version_check(memc
, 1, 4, 4))
3625 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3626 test_compare(MEMCACHED_SUCCESS
, rc
);
3627 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3630 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3633 static test_return_t
pre_replication(memcached_st
*memc
)
3635 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3638 * Make sure that we store the item on all servers
3639 * (master + replicas == number of servers)
3641 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3642 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3644 return TEST_SUCCESS
;
3648 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3650 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3652 return pre_nonblock(memc
);
3656 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3660 #ifdef HARD_MALLOC_TESTS
3661 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3669 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3673 #ifdef HARD_MALLOC_TESTS
3674 void *ret
= malloc(size
+ 8);
3677 ret
= (void*)((caddr_t
)ret
+ 8);
3680 void *ret
= malloc(size
);
3685 memset(ret
, 0xff, size
);
3692 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3694 #ifdef HARD_MALLOC_TESTS
3695 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3696 void *nmem
= realloc(real_ptr
, size
+ 8);
3701 ret
= (void*)((caddr_t
)nmem
+ 8);
3707 return realloc(mem
, size
);
3712 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3714 #ifdef HARD_MALLOC_TESTS
3715 void *mem
= my_malloc(ptr
, nelem
* size
);
3718 memset(mem
, 0, nelem
* size
);
3724 return calloc(nelem
, size
);
3728 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3730 memcached_return_t rc
;
3731 const char *key
= "mine";
3734 /* Make sure be default none exists */
3735 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3736 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3738 /* Test a clean set */
3739 test_compare(MEMCACHED_SUCCESS
,
3740 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3742 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3744 test_memcmp(value
, key
, 4);
3745 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3747 /* Test that we can turn it off */
3748 test_compare(MEMCACHED_SUCCESS
,
3749 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3751 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3753 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3755 /* Now setup for main test */
3756 test_compare(MEMCACHED_SUCCESS
,
3757 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3759 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3761 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3762 test_memcmp(value
, key
, 4);
3764 /* Set to Zero, and then Set to something too large */
3767 memset(long_key
, 0, 255);
3769 test_compare(MEMCACHED_SUCCESS
,
3770 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3772 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3774 test_true(rc
== MEMCACHED_FAILURE
);
3775 test_true(value
== NULL
);
3777 /* Test a long key for failure */
3778 /* TODO, extend test to determine based on setting, what result should be */
3779 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3780 test_compare(MEMCACHED_SUCCESS
,
3781 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3783 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3784 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3785 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3786 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3788 /* Test for a bad prefix, but with a short key */
3789 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3790 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3792 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3793 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3796 return TEST_SUCCESS
;
3799 static test_return_t
set_namespace(memcached_st
*memc
)
3801 memcached_return_t rc
;
3802 const char *key
= "mine";
3805 /* Make sure be default none exists */
3806 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3807 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3809 /* Test a clean set */
3810 test_compare(MEMCACHED_SUCCESS
,
3811 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3813 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3815 test_memcmp(value
, key
, 4);
3816 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3818 return TEST_SUCCESS
;
3821 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3823 test_return_if(pre_binary(memc
));
3824 test_return_if(set_namespace(memc
));
3826 return TEST_SUCCESS
;
3829 #ifdef MEMCACHED_ENABLE_DEPRECATED
3830 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3832 void *test_ptr
= NULL
;
3835 memcached_malloc_fn malloc_cb
=
3836 (memcached_malloc_fn
)my_malloc
;
3837 cb_ptr
= *(void **)&malloc_cb
;
3838 memcached_return_t rc
;
3840 test_compare(MEMCACHED_SUCCESS
,
3841 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3842 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3843 test_compare(MEMCACHED_SUCCESS
, rc
);
3844 test_true(test_ptr
== cb_ptr
);
3848 memcached_realloc_fn realloc_cb
=
3849 (memcached_realloc_fn
)my_realloc
;
3850 cb_ptr
= *(void **)&realloc_cb
;
3851 memcached_return_t rc
;
3853 test_compare(MEMCACHED_SUCCESS
,
3854 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3855 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3856 test_compare(MEMCACHED_SUCCESS
, rc
);
3857 test_true(test_ptr
== cb_ptr
);
3861 memcached_free_fn free_cb
=
3862 (memcached_free_fn
)my_free
;
3863 cb_ptr
= *(void **)&free_cb
;
3864 memcached_return_t rc
;
3866 test_compare(MEMCACHED_SUCCESS
,
3867 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3868 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3869 test_compare(MEMCACHED_SUCCESS
, rc
);
3870 test_true(test_ptr
== cb_ptr
);
3873 return TEST_SUCCESS
;
3878 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3880 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3881 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3882 my_realloc
, my_calloc
, NULL
));
3884 test_compare(MEMCACHED_SUCCESS
,
3885 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3886 my_realloc
, my_calloc
, NULL
));
3888 memcached_malloc_fn mem_malloc
;
3889 memcached_free_fn mem_free
;
3890 memcached_realloc_fn mem_realloc
;
3891 memcached_calloc_fn mem_calloc
;
3892 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3893 &mem_realloc
, &mem_calloc
);
3895 test_true(mem_malloc
== my_malloc
);
3896 test_true(mem_realloc
== my_realloc
);
3897 test_true(mem_calloc
== my_calloc
);
3898 test_true(mem_free
== my_free
);
3900 return TEST_SUCCESS
;
3903 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3906 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3907 memcached_hash_t hash
;
3908 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3909 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3912 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3913 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3915 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3917 if (hash
!= MEMCACHED_HASH_CRC
)
3918 return TEST_SKIPPED
;
3920 return TEST_SUCCESS
;
3923 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3926 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3927 memcached_hash_t hash
;
3928 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3929 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3934 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3935 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3937 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3939 if (hash
!= MEMCACHED_HASH_HSIEH
)
3940 return TEST_SKIPPED
;
3943 return TEST_SUCCESS
;
3946 static test_return_t
enable_cas(memcached_st
*memc
)
3948 unsigned int set
= 1;
3950 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3952 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3954 return TEST_SUCCESS
;
3957 return TEST_SKIPPED
;
3960 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3962 memcached_version(memc
);
3964 memcached_server_instance_st instance
=
3965 memcached_server_instance_by_position(memc
, 0);
3967 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3968 or instance
->minor_version
> 2)
3970 return TEST_SUCCESS
;
3973 return TEST_SKIPPED
;
3976 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3980 memcached_servers_reset(memc
);
3981 const char *socket_file
= default_socket();
3983 test_skip(0, stat(socket_file
, &buf
));
3985 test_compare(MEMCACHED_SUCCESS
,
3986 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
3988 return TEST_SUCCESS
;
3991 static test_return_t
pre_nodelay(memcached_st
*memc
)
3993 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3994 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3996 return TEST_SUCCESS
;
3999 static test_return_t
pre_settimer(memcached_st
*memc
)
4001 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4002 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4004 return TEST_SUCCESS
;
4007 static test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
4009 const uint64_t timeout
= 100; // Not using, just checking that it sets
4011 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4013 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
4015 return TEST_SUCCESS
;
4018 static test_return_t
noreply_test(memcached_st
*memc
)
4020 test_compare(MEMCACHED_SUCCESS
,
4021 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4022 test_compare(MEMCACHED_SUCCESS
,
4023 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1));
4024 test_compare(MEMCACHED_SUCCESS
,
4025 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4026 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
4027 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
4028 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
4030 memcached_return_t ret
;
4031 for (int count
= 0; count
< 5; ++count
)
4033 for (size_t x
= 0; x
< 100; ++x
)
4036 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4037 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4039 size_t len
= (size_t)check_length
;
4044 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4047 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4050 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4053 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4056 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4062 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, ret
));
4066 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4067 ** API and is _ONLY_ done this way to verify that the library works the
4068 ** way it is supposed to do!!!!
4071 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4073 memcached_server_instance_st instance
=
4074 memcached_server_instance_by_position(memc
, x
);
4075 no_msg
+=(int)(instance
->cursor_active
);
4078 test_true(no_msg
== 0);
4079 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4082 ** Now validate that all items was set properly!
4084 for (size_t x
= 0; x
< 100; ++x
)
4088 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4090 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4092 size_t len
= (size_t)check_length
;
4095 char* value
=memcached_get(memc
, key
, strlen(key
),
4096 &length
, &flags
, &ret
);
4097 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
4100 case 0: /* FALLTHROUGH */
4101 case 1: /* FALLTHROUGH */
4103 test_true(strncmp(value
, key
, len
) == 0);
4104 test_true(len
== length
);
4107 test_true(length
== len
* 2);
4110 test_true(length
== len
* 3);
4120 /* Try setting an illegal cas value (should not return an error to
4121 * the caller (because we don't expect a return message from the server)
4123 const char* keys
[]= {"0"};
4124 size_t lengths
[]= {1};
4127 memcached_result_st results_obj
;
4128 memcached_result_st
*results
;
4129 test_compare(MEMCACHED_SUCCESS
,
4130 memcached_mget(memc
, keys
, lengths
, 1));
4132 results
= memcached_result_create(memc
, &results_obj
);
4134 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4136 test_compare(MEMCACHED_SUCCESS
, ret
);
4137 uint64_t cas
= memcached_result_cas(results
);
4138 memcached_result_free(&results_obj
);
4140 test_compare(MEMCACHED_SUCCESS
,
4141 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4144 * The item will have a new cas value, so try to set it again with the old
4145 * value. This should fail!
4147 test_compare(MEMCACHED_SUCCESS
,
4148 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4149 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4150 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4151 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4154 return TEST_SUCCESS
;
4157 static test_return_t
analyzer_test(memcached_st
*memc
)
4159 memcached_return_t rc
;
4160 memcached_stat_st
*memc_stat
;
4161 memcached_analysis_st
*report
;
4163 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4164 test_compare(MEMCACHED_SUCCESS
, rc
);
4165 test_true(memc_stat
);
4167 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4168 test_compare(MEMCACHED_SUCCESS
, rc
);
4172 memcached_stat_free(NULL
, memc_stat
);
4174 return TEST_SUCCESS
;
4177 /* Count the objects */
4179 static test_return_t
dump_test(memcached_st
*memc
)
4181 /* No support for Binary protocol yet */
4182 test_skip(false, memc
->flags
.binary_protocol
);
4184 test_compare(TEST_SUCCESS
, set_test3(memc
));
4186 // confirm_key_count() call dump
4187 size_t counter
= confirm_key_count(memc
);
4189 /* We may have more then 32 if our previous flush has not completed */
4190 test_true(counter
>= 32);
4192 return TEST_SUCCESS
;
4195 struct test_pool_context_st
{
4196 memcached_pool_st
* pool
;
4200 static void* connection_release(void *arg
)
4202 test_pool_context_st
*resource
= static_cast<test_pool_context_st
*>(arg
);
4205 // Release all of the memc we are holding
4206 assert(memcached_success(memcached_pool_push(resource
->pool
, resource
->mmc
)));
4210 #define POOL_SIZE 10
4211 static test_return_t
connection_pool_test(memcached_st
*memc
)
4213 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4214 test_true(pool
!= NULL
);
4215 memcached_st
*mmc
[POOL_SIZE
];
4216 memcached_return_t rc
;
4218 // Fill up our array that we will store the memc that are in the pool
4219 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4221 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4222 test_true(mmc
[x
] != NULL
);
4223 test_compare(MEMCACHED_SUCCESS
, rc
);
4226 // All memc should be gone
4227 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4228 test_compare(MEMCACHED_SUCCESS
, rc
);
4231 test_pool_context_st item
= { pool
, mmc
[9] };
4233 pthread_create(&tid
, NULL
, connection_release
, &item
);
4234 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4235 test_compare(MEMCACHED_SUCCESS
, rc
);
4236 pthread_join(tid
, NULL
);
4238 const char *key
= "key";
4239 size_t keylen
= strlen(key
);
4241 // verify that I can do ops with all connections
4242 test_compare(MEMCACHED_SUCCESS
,
4243 memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0));
4245 for (uint64_t x
= 0; x
< POOL_SIZE
; ++x
)
4247 uint64_t number_value
;
4248 test_compare(MEMCACHED_SUCCESS
,
4249 memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
));
4250 test_compare(number_value
, (x
+1));
4254 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4256 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[x
]));
4260 /* verify that I can set behaviors on the pool when I don't have all
4261 * of the connections in the pool. It should however be enabled
4262 * when I push the item into the pool
4264 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4267 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4268 test_compare(MEMCACHED_SUCCESS
, rc
);
4270 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4273 test_compare(UINT64_C(9999), memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4274 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[1]));
4275 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4277 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4278 test_compare(UINT64_C(9999), memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4279 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4281 test_true(memcached_pool_destroy(pool
) == memc
);
4283 return TEST_SUCCESS
;
4286 static test_return_t
util_version_test(memcached_st
*memc
)
4288 bool if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4289 test_true(if_successful
);
4291 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4293 // We expect failure
4296 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4297 fprintf(stderr
, "\nDumping Server Information\n\n");
4298 memcached_server_fn callbacks
[1];
4300 callbacks
[0]= dump_server_information
;
4301 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4302 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4304 test_true(if_successful
== false);
4306 memcached_server_instance_st instance
=
4307 memcached_server_instance_by_position(memc
, 0);
4309 memcached_version(memc
);
4311 // We only use one binary when we test, so this should be just fine.
4312 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4313 test_true(if_successful
== true);
4315 if (instance
->micro_version
> 0)
4317 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4319 else if (instance
->minor_version
> 0)
4321 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4323 else if (instance
->major_version
> 0)
4325 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4328 test_true(if_successful
== true);
4330 if (instance
->micro_version
> 0)
4332 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4334 else if (instance
->minor_version
> 0)
4336 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4338 else if (instance
->major_version
> 0)
4340 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4343 test_true(if_successful
== false);
4345 return TEST_SUCCESS
;
4348 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4350 memcached_return_t rc
;
4351 memcached_server_instance_st instance
=
4352 memcached_server_instance_by_position(memc
, 0);
4354 // Test both the version that returns a code, and the one that does not.
4355 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4356 memcached_server_port(instance
) -1, NULL
) == -1);
4358 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4359 memcached_server_port(instance
) -1, &rc
) == -1);
4360 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4362 return TEST_SUCCESS
;
4366 static test_return_t
getpid_test(memcached_st
*memc
)
4368 memcached_return_t rc
;
4369 memcached_server_instance_st instance
=
4370 memcached_server_instance_by_position(memc
, 0);
4372 // Test both the version that returns a code, and the one that does not.
4373 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4374 memcached_server_port(instance
), NULL
) > -1);
4376 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4377 memcached_server_port(instance
), &rc
) > -1);
4378 test_compare(MEMCACHED_SUCCESS
, rc
);
4380 return TEST_SUCCESS
;
4383 static test_return_t
ping_test(memcached_st
*memc
)
4385 memcached_return_t rc
;
4386 memcached_server_instance_st instance
=
4387 memcached_server_instance_by_position(memc
, 0);
4389 // Test both the version that returns a code, and the one that does not.
4390 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4391 memcached_server_port(instance
), NULL
));
4393 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4394 memcached_server_port(instance
), &rc
));
4396 test_compare(MEMCACHED_SUCCESS
, rc
);
4398 return TEST_SUCCESS
;
4403 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4407 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4408 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4409 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4410 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4411 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4412 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4413 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4414 #ifdef HAVE_HSIEH_HASH
4415 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4417 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4418 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4419 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4421 return TEST_SUCCESS
;
4425 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4427 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4428 #ifdef HAVE_HSIEH_HASH
4429 expected_rc
= MEMCACHED_SUCCESS
;
4431 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4432 (uint64_t)MEMCACHED_HASH_HSIEH
);
4433 test_true(rc
== expected_rc
);
4435 return TEST_SUCCESS
;
4438 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4440 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4441 #ifdef HAVE_MURMUR_HASH
4442 expected_rc
= MEMCACHED_SUCCESS
;
4444 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4445 (uint64_t)MEMCACHED_HASH_MURMUR
);
4446 test_true(rc
== expected_rc
);
4448 return TEST_SUCCESS
;
4451 static test_return_t
one_at_a_time_run (memcached_st
*)
4456 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4460 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
);
4461 test_true(one_at_a_time_values
[x
] == hash_val
);
4464 return TEST_SUCCESS
;
4467 static test_return_t
md5_run (memcached_st
*)
4472 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4476 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4477 test_true(md5_values
[x
] == hash_val
);
4480 return TEST_SUCCESS
;
4483 static test_return_t
crc_run (memcached_st
*)
4488 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4492 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4493 test_true(crc_values
[x
] == hash_val
);
4496 return TEST_SUCCESS
;
4499 static test_return_t
fnv1_64_run (memcached_st
*)
4504 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4508 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4509 test_true(fnv1_64_values
[x
] == hash_val
);
4512 return TEST_SUCCESS
;
4515 static test_return_t
fnv1a_64_run (memcached_st
*)
4520 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4524 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4525 test_true(fnv1a_64_values
[x
] == hash_val
);
4528 return TEST_SUCCESS
;
4531 static test_return_t
fnv1_32_run (memcached_st
*)
4536 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4540 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4541 test_true(fnv1_32_values
[x
] == hash_val
);
4544 return TEST_SUCCESS
;
4547 static test_return_t
fnv1a_32_run (memcached_st
*)
4552 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4556 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4557 test_true(fnv1a_32_values
[x
] == hash_val
);
4560 return TEST_SUCCESS
;
4563 static test_return_t
hsieh_run (memcached_st
*)
4568 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4572 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4573 test_true(hsieh_values
[x
] == hash_val
);
4576 return TEST_SUCCESS
;
4579 static test_return_t
murmur_run (memcached_st
*)
4581 #ifdef WORDS_BIGENDIAN
4582 (void)murmur_values
;
4583 return TEST_SKIPPED
;
4588 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4592 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
4593 test_true(murmur_values
[x
] == hash_val
);
4596 return TEST_SUCCESS
;
4600 static test_return_t
jenkins_run (memcached_st
*)
4605 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4609 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4610 test_true(jenkins_values
[x
] == hash_val
);
4613 return TEST_SUCCESS
;
4616 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *context
)
4619 return libhashkit_md5(string
, string_length
);
4622 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *context
)
4625 return libhashkit_crc32(string
, string_length
);
4628 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4634 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5"));
4636 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};
4637 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};
4639 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4641 hashkit_clone(&new_kit
, kit
);
4642 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4644 memcached_set_hashkit(memc
, &new_kit
);
4647 Verify Setting the hash.
4649 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4653 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4654 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4659 Now check memcached_st.
4661 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4665 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4666 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4669 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4671 memcached_set_hashkit(memc
, &new_kit
);
4674 Verify Setting the hash.
4676 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4680 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4681 test_true(crc_values
[x
] == hash_val
);
4684 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4688 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4689 test_compare(crc_hosts
[x
], hash_val
);
4692 memcached_free(memc
);
4694 return TEST_SUCCESS
;
4698 Test case adapted from John Gorman <johngorman2@gmail.com>
4700 We are testing the error condition when we connect to a server via memcached_get()
4701 but find that the server is not available.
4703 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4705 const char *key
= "MemcachedLives";
4708 memcached_return rc
;
4711 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4713 // See if memcached is reachable.
4714 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4718 test_true(memcached_failed(rc
));
4720 memcached_free(tl_memc_h
);
4722 return TEST_SUCCESS
;
4726 We connect to a server which exists, but search for a key that does not exist.
4728 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4730 const char *key
= "MemcachedKeyNotEXIST";
4733 memcached_return rc
;
4735 // See if memcached is reachable.
4736 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4740 test_compare(MEMCACHED_NOTFOUND
, rc
);
4742 return TEST_SUCCESS
;
4746 Test case adapted from John Gorman <johngorman2@gmail.com>
4748 We are testing the error condition when we connect to a server via memcached_get_by_key()
4749 but find that the server is not available.
4751 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4754 memcached_st
*tl_memc_h
;
4755 memcached_server_st
*servers
;
4757 const char *key
= "MemcachedLives";
4760 memcached_return rc
;
4764 tl_memc_h
= memcached_create(NULL
);
4765 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4766 memcached_server_push(tl_memc_h
, servers
);
4767 memcached_server_list_free(servers
);
4769 // See if memcached is reachable.
4770 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4774 test_true(memcached_failed(rc
));
4776 memcached_free(tl_memc_h
);
4778 return TEST_SUCCESS
;
4782 We connect to a server which exists, but search for a key that does not exist.
4784 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4786 const char *key
= "MemcachedKeyNotEXIST";
4789 memcached_return rc
;
4792 // See if memcached is reachable.
4793 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4797 test_compare(MEMCACHED_NOTFOUND
, rc
);
4799 return TEST_SUCCESS
;
4802 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4804 test_return_t test_rc
;
4805 test_rc
= pre_binary(memc
);
4807 if (test_rc
!= TEST_SUCCESS
)
4810 const char *key
= "regression_bug_434484";
4811 size_t keylen
= strlen(key
);
4813 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4814 test_compare(MEMCACHED_NOTSTORED
, ret
);
4816 size_t size
= 2048 * 1024;
4817 char *data
= (char*)calloc(1, size
);
4819 test_compare(MEMCACHED_E2BIG
,
4820 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4823 return TEST_SUCCESS
;
4826 static test_return_t
regression_bug_434843(memcached_st
*memc
)
4828 test_return_t test_rc
;
4829 test_rc
= pre_binary(memc
);
4831 if (test_rc
!= TEST_SUCCESS
)
4834 memcached_return_t rc
;
4836 memcached_execute_fn callbacks
[]= { &callback_counter
};
4839 * I only want to hit only _one_ server so I know the number of requests I'm
4840 * sending in the pipleine to the server. Let's try to do a multiget of
4841 * 1024 (that should satisfy most users don't you think?). Future versions
4842 * will include a mget_execute function call if you need a higher number.
4844 uint32_t number_of_hosts
= memcached_server_count(memc
);
4845 memc
->number_of_hosts
= 1;
4846 const size_t max_keys
= 1024;
4847 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4848 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4850 for (size_t x
= 0; x
< max_keys
; ++x
)
4854 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4860 * Run two times.. the first time we should have 100% cache miss,
4861 * and the second time we should have 100% cache hits
4863 for (size_t y
= 0; y
< 2; y
++)
4865 test_compare(MEMCACHED_SUCCESS
,
4866 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4868 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4869 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4873 /* The first iteration should give me a 100% cache miss. verify that*/
4874 char blob
[1024]= { 0 };
4876 test_false(counter
);
4878 for (size_t x
= 0; x
< max_keys
; ++x
)
4880 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4881 blob
, sizeof(blob
), 0, 0);
4882 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4887 /* Verify that we received all of the key/value pairs */
4888 test_compare(counter
, max_keys
);
4892 /* Release allocated resources */
4893 for (size_t x
= 0; x
< max_keys
; ++x
)
4900 memc
->number_of_hosts
= number_of_hosts
;
4902 return TEST_SUCCESS
;
4905 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4907 memcached_return_t rc
;
4908 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4909 test_compare(MEMCACHED_SUCCESS
, rc
);
4911 return regression_bug_434843(memc
);
4914 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4916 memcached_return_t rc
;
4917 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4918 test_compare(MEMCACHED_SUCCESS
, rc
);
4920 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4921 test_compare(MEMCACHED_SUCCESS
, rc
);
4922 test_true(bytes_str
);
4923 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4925 test_compare(MEMCACHED_SUCCESS
, rc
);
4926 test_true(bytes_read_str
);
4928 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4929 "bytes_written", &rc
);
4930 test_compare(MEMCACHED_SUCCESS
, rc
);
4931 test_true(bytes_written_str
);
4933 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4934 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4935 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4937 test_true(bytes
!= bytes_read
);
4938 test_true(bytes
!= bytes_written
);
4940 /* Release allocated resources */
4942 free(bytes_read_str
);
4943 free(bytes_written_str
);
4944 memcached_stat_free(NULL
, memc_stat
);
4946 return TEST_SUCCESS
;
4950 * The test case isn't obvious so I should probably document why
4951 * it works the way it does. Bug 442914 was caused by a bug
4952 * in the logic in memcached_purge (it did not handle the case
4953 * where the number of bytes sent was equal to the watermark).
4954 * In this test case, create messages so that we hit that case
4955 * and then disable noreply mode and issue a new command to
4956 * verify that it isn't stuck. If we change the format for the
4957 * delete command or the watermarks, we need to update this
4960 static test_return_t
regression_bug_442914(memcached_st
*memc
)
4962 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4963 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4965 uint32_t number_of_hosts
= memcached_server_count(memc
);
4966 memc
->number_of_hosts
= 1;
4971 for (uint32_t x
= 0; x
< 250; ++x
)
4973 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4974 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4975 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4978 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
4981 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4982 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4984 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4985 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
4987 memc
->number_of_hosts
= number_of_hosts
;
4989 return TEST_SUCCESS
;
4992 static test_return_t
regression_bug_447342(memcached_st
*memc
)
4994 memcached_server_instance_st instance_one
;
4995 memcached_server_instance_st instance_two
;
4997 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4998 return TEST_SKIPPED
;
5000 test_compare(MEMCACHED_SUCCESS
,
5001 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
5003 const unsigned int max_keys
= 100;
5004 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
5005 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5007 for (unsigned int x
= 0; x
< max_keys
; ++x
)
5011 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5014 test_compare(MEMCACHED_SUCCESS
,
5015 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
5019 ** We are using the quiet commands to store the replicas, so we need
5020 ** to ensure that all of them are processed before we can continue.
5021 ** In the test we go directly from storing the object to trying to
5022 ** receive the object from all of the different servers, so we
5023 ** could end up in a race condition (the memcached server hasn't yet
5024 ** processed the quiet command from the replication set when it process
5025 ** the request from the other client (created by the clone)). As a
5026 ** workaround for that we call memcached_quit to send the quit command
5027 ** to the server and wait for the response ;-) If you use the test code
5028 ** as an example for your own code, please note that you shouldn't need
5031 memcached_quit(memc
);
5033 /* Verify that all messages are stored, and we didn't stuff too much
5036 test_compare(MEMCACHED_SUCCESS
,
5037 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5039 unsigned int counter
= 0;
5040 memcached_execute_fn callbacks
[]= { &callback_counter
};
5041 test_compare(MEMCACHED_SUCCESS
,
5042 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5044 /* Verify that we received all of the key/value pairs */
5045 test_compare(counter
, max_keys
);
5047 memcached_quit(memc
);
5049 * Don't do the following in your code. I am abusing the internal details
5050 * within the library, and this is not a supported interface.
5051 * This is to verify correct behavior in the library. Fake that two servers
5054 instance_one
= memcached_server_instance_by_position(memc
, 0);
5055 instance_two
= memcached_server_instance_by_position(memc
, 2);
5056 in_port_t port0
= instance_one
->port
;
5057 in_port_t port2
= instance_two
->port
;
5059 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5060 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5062 test_compare(MEMCACHED_SUCCESS
,
5063 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5066 test_compare(MEMCACHED_SUCCESS
,
5067 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5068 test_compare(counter
, (unsigned int)max_keys
);
5070 /* restore the memc handle */
5071 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5072 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5074 memcached_quit(memc
);
5076 /* Remove half of the objects */
5077 for (size_t x
= 0; x
< max_keys
; ++x
)
5081 test_compare(MEMCACHED_SUCCESS
,
5082 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
5086 memcached_quit(memc
);
5087 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5088 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5090 /* now retry the command, this time we should have cache misses */
5091 test_compare(MEMCACHED_SUCCESS
,
5092 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5095 test_compare(MEMCACHED_SUCCESS
,
5096 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5097 test_compare(counter
, (unsigned int)(max_keys
>> 1));
5099 /* Release allocated resources */
5100 for (size_t x
= 0; x
< max_keys
; ++x
)
5107 /* restore the memc handle */
5108 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5109 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5111 return TEST_SUCCESS
;
5114 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5116 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5117 test_true(memc_clone
);
5118 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5120 memcached_server_instance_st instance
=
5121 memcached_server_instance_by_position(memc_clone
, 0);
5123 if (instance
->major_version
> 1 ||
5124 (instance
->major_version
== 1 &&
5125 instance
->minor_version
> 2))
5127 /* Binary protocol doesn't support deferred delete */
5128 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5129 test_true(bin_clone
);
5130 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5131 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
5132 memcached_free(bin_clone
);
5134 memcached_quit(memc_clone
);
5136 /* If we know the server version, deferred delete should fail
5137 * with invalid arguments */
5138 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
5140 /* If we don't know the server version, we should get a protocol error */
5141 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5143 /* but there is a bug in some of the memcached servers (1.4) that treats
5144 * the counter as noreply so it doesn't send the proper error message
5146 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5148 /* And buffered mode should be disabled and we should get protocol error */
5149 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5150 rc
= memcached_delete(memc
, "foo", 3, 1);
5151 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5153 /* Same goes for noreply... */
5154 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5155 rc
= memcached_delete(memc
, "foo", 3, 1);
5156 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5158 /* but a normal request should go through (and be buffered) */
5159 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
5160 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
5162 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
5163 /* unbuffered noreply should be success */
5164 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
5165 /* unbuffered with reply should be not found... */
5166 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5167 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
5170 memcached_free(memc_clone
);
5171 return TEST_SUCCESS
;
5175 /* Test memcached_server_get_last_disconnect
5176 * For a working server set, shall be NULL
5177 * For a set of non existing server, shall not be NULL
5179 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5181 memcached_return_t rc
;
5182 memcached_server_instance_st disconnected_server
;
5184 /* With the working set of server */
5185 const char *key
= "marmotte";
5186 const char *value
= "milka";
5188 memcached_reset_last_disconnected_server(memc
);
5189 test_false(memc
->last_disconnected_server
);
5190 rc
= memcached_set(memc
, key
, strlen(key
),
5191 value
, strlen(value
),
5192 (time_t)0, (uint32_t)0);
5193 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5195 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5196 test_false(disconnected_server
);
5198 /* With a non existing server */
5200 memcached_server_st
*servers
;
5202 const char *server_list
= "localhost:9";
5204 servers
= memcached_servers_parse(server_list
);
5206 mine
= memcached_create(NULL
);
5207 rc
= memcached_server_push(mine
, servers
);
5208 test_compare(MEMCACHED_SUCCESS
, rc
);
5209 memcached_server_list_free(servers
);
5212 rc
= memcached_set(mine
, key
, strlen(key
),
5213 value
, strlen(value
),
5214 (time_t)0, (uint32_t)0);
5215 test_true(memcached_failed(rc
));
5217 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5218 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5219 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5220 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5222 memcached_quit(mine
);
5223 memcached_free(mine
);
5225 return TEST_SUCCESS
;
5228 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5230 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5231 char buffer
[BUFSIZ
];
5233 test_compare(MEMCACHED_SUCCESS
,
5234 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5236 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5239 // We will just use the error strings as our keys
5240 uint32_t counter
= 100;
5243 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5245 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5246 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5247 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
5249 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5250 test_true(disconnected_server
);
5251 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5252 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5256 memcached_reset_last_disconnected_server(memc
);
5261 memcached_free(memc
);
5263 return TEST_SUCCESS
;
5266 static test_return_t
test_verbosity(memcached_st
*memc
)
5268 memcached_verbosity(memc
, 3);
5270 return TEST_SUCCESS
;
5274 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5275 const char *key
, size_t key_length
,
5276 const char *value
, size_t value_length
,
5286 return MEMCACHED_SUCCESS
;
5289 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5291 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5292 test_compare(MEMCACHED_SUCCESS
, rc
);
5294 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5295 test_compare(MEMCACHED_SUCCESS
, rc
);
5297 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5298 test_compare(MEMCACHED_SUCCESS
, rc
);
5300 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5301 test_compare(MEMCACHED_SUCCESS
, rc
);
5303 return TEST_SUCCESS
;
5307 * This test ensures that the failure counter isn't incremented during
5308 * normal termination of the memcached instance.
5310 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5312 memcached_return_t rc
;
5313 memcached_server_instance_st instance
;
5315 /* Set value to force connection to the server */
5316 const char *key
= "marmotte";
5317 const char *value
= "milka";
5320 * Please note that I'm abusing the internal structures in libmemcached
5321 * in a non-portable way and you shouldn't be doing this. I'm only
5322 * doing this in order to verify that the library works the way it should
5324 uint32_t number_of_hosts
= memcached_server_count(memc
);
5325 memc
->number_of_hosts
= 1;
5327 /* Ensure that we are connected to the server by setting a value */
5328 rc
= memcached_set(memc
, key
, strlen(key
),
5329 value
, strlen(value
),
5330 (time_t)0, (uint32_t)0);
5331 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5334 instance
= memcached_server_instance_by_position(memc
, 0);
5335 /* The test is to see that the memcached_quit doesn't increase the
5336 * the server failure conter, so let's ensure that it is zero
5337 * before sending quit
5339 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5341 memcached_quit(memc
);
5343 /* Verify that it memcached_quit didn't increment the failure counter
5344 * Please note that this isn't bullet proof, because an error could
5347 test_zero(instance
->server_failure_counter
);
5349 /* restore the instance */
5350 memc
->number_of_hosts
= number_of_hosts
;
5352 return TEST_SUCCESS
;
5356 * This tests ensures expected disconnections (for some behavior changes
5357 * for instance) do not wrongly increase failure counter
5359 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5361 memcached_return rc
;
5363 memcached_st
*memc_clone
;
5364 memc_clone
= memcached_clone(NULL
, memc
);
5365 test_true(memc_clone
);
5367 /* Set value to force connection to the server */
5368 const char *key
= "marmotte";
5369 const char *value
= "milka";
5370 char *string
= NULL
;
5371 size_t string_length
;
5374 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5375 value
, strlen(value
),
5376 (time_t)0, (uint32_t)0);
5377 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5380 /* put failure limit to 1 */
5381 test_compare(MEMCACHED_SUCCESS
,
5382 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1));
5384 /* Put a retry timeout to effectively activate failure_limit effect */
5385 test_compare(MEMCACHED_SUCCESS
,
5386 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
5388 /* change behavior that triggers memcached_quit()*/
5389 test_compare(MEMCACHED_SUCCESS
,
5390 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5393 /* Check if we still are connected */
5394 string
= memcached_get(memc_clone
, key
, strlen(key
),
5395 &string_length
, &flags
, &rc
);
5397 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5400 memcached_free(memc_clone
);
5402 return TEST_SUCCESS
;
5409 * Test that ensures mget_execute does not end into recursive calls that finally fails
5411 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5413 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5414 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5415 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5416 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5417 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5420 return TEST_SKIPPED
; // My MAC can't handle this test
5424 * I only want to hit _one_ server so I know the number of requests I'm
5425 * sending in the pipeline.
5427 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5428 memc
->number_of_hosts
= 1;
5429 size_t max_keys
= 20480;
5432 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5433 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5435 /* First add all of the items.. */
5436 char blob
[1024]= { 0 };
5437 for (size_t x
= 0; x
< max_keys
; ++x
)
5440 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5443 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5444 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5449 /* Try to get all of them with a large multiget */
5451 memcached_execute_function callbacks
[]= { &callback_counter
};
5452 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5453 (size_t)max_keys
, callbacks
, &counter
, 1);
5454 test_compare(MEMCACHED_SUCCESS
, rc
);
5456 char* the_value
= NULL
;
5457 char the_key
[MEMCACHED_MAX_KEY
];
5458 size_t the_key_length
;
5459 size_t the_value_length
;
5463 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5465 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5471 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5474 test_compare(MEMCACHED_END
, rc
);
5476 /* Verify that we got all of the items */
5477 test_compare(counter
, max_keys
);
5480 /* Release all allocated resources */
5481 for (size_t x
= 0; x
< max_keys
; ++x
)
5488 memc
->number_of_hosts
= number_of_hosts
;
5490 return TEST_SUCCESS
;
5493 static test_return_t
regression_bug_583031(memcached_st
*)
5495 memcached_st
*memc
= memcached_create(NULL
);
5497 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5499 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5500 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5501 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5502 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5503 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5504 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5506 memcached_return_t rc
;
5510 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5514 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5516 memcached_free(memc
);
5518 return TEST_SUCCESS
;
5521 static test_return_t
regression_bug_581030(memcached_st
*)
5524 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5525 test_false(local_stat
);
5527 memcached_stat_free(NULL
, NULL
);
5530 return TEST_SUCCESS
;
5533 #define regression_bug_655423_COUNT 6000
5534 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5536 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5537 memc
= NULL
; // Just to make sure it is not used
5542 return TEST_SKIPPED
;
5545 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5546 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5547 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5548 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5550 memset(payload
, int('x'), sizeof(payload
));
5552 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5554 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5555 snprintf(key
, sizeof(key
), "%u", x
);
5557 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5560 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5562 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5563 snprintf(key
, sizeof(key
), "%u", x
);
5565 size_t value_length
;
5566 memcached_return_t rc
;
5567 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5569 if (rc
== MEMCACHED_NOTFOUND
)
5572 test_zero(value_length
);
5576 test_compare(MEMCACHED_SUCCESS
, rc
);
5578 test_compare(100LLU, value_length
);
5582 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5583 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5584 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5586 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5587 snprintf(key
, sizeof(key
), "%u", x
);
5589 keys
[x
]= strdup(key
);
5591 key_length
[x
]= strlen(key
);
5592 test_true(key_length
[x
]);
5595 test_compare(MEMCACHED_SUCCESS
,
5596 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5599 memcached_result_st
*result
= NULL
;
5600 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5602 test_compare(size_t(100), memcached_result_length(result
));
5606 test_true(count
> 100); // If we don't get back atleast this, something is up
5608 /* Release all allocated resources */
5609 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5617 memcached_free(clone
);
5619 return TEST_SUCCESS
;
5623 * Test that ensures that buffered set to not trigger problems during io_flush
5625 #define regression_bug_490520_COUNT 200480
5626 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5628 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5629 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5630 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5631 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5632 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5634 memc
->number_of_hosts
= 1;
5636 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5637 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5639 /* First add all of the items.. */
5640 char blob
[3333] = {0};
5641 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5644 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5648 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5649 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5652 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5659 return TEST_SUCCESS
;
5662 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5664 fprintf(stderr
, "Iteration #%u: ", it
);
5666 if (error
== MEMCACHED_ERRNO
)
5668 fprintf(stderr
, "system error %d from %s: %s\n",
5669 errno
, what
, strerror(errno
));
5673 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5674 memcached_strerror(mc
, error
));
5678 #define TEST_CONSTANT_CREATION 200
5680 static test_return_t
regression_bug_(memcached_st
*memc
)
5682 const char *remote_server
;
5685 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5687 return TEST_SKIPPED
;
5690 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5692 memcached_st
* mc
= memcached_create(NULL
);
5693 memcached_return rc
;
5695 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5696 if (rc
!= MEMCACHED_SUCCESS
)
5698 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5701 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5702 if (rc
!= MEMCACHED_SUCCESS
)
5704 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5707 rc
= memcached_server_add(mc
, remote_server
, 0);
5708 if (rc
!= MEMCACHED_SUCCESS
)
5710 memcached_die(mc
, rc
, "memcached_server_add", x
);
5713 const char *set_key
= "akey";
5714 const size_t set_key_len
= strlen(set_key
);
5715 const char *set_value
= "a value";
5716 const size_t set_value_len
= strlen(set_value
);
5718 if (rc
== MEMCACHED_SUCCESS
)
5722 size_t get_value_len
;
5724 uint32_t get_value_flags
;
5726 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5727 &get_value_flags
, &rc
);
5728 if (rc
!= MEMCACHED_SUCCESS
)
5730 memcached_die(mc
, rc
, "memcached_get", x
);
5736 (get_value_len
!= set_value_len
5737 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5739 fprintf(stderr
, "Values don't match?\n");
5740 rc
= MEMCACHED_FAILURE
;
5746 rc
= memcached_set(mc
,
5747 set_key
, set_key_len
,
5748 set_value
, set_value_len
,
5752 if (rc
!= MEMCACHED_SUCCESS
)
5754 memcached_die(mc
, rc
, "memcached_set", x
);
5761 if (rc
!= MEMCACHED_SUCCESS
)
5767 return TEST_SUCCESS
;
5770 /* Clean the server before beginning testing */
5772 {"util_version", true, (test_callback_fn
*)util_version_test
},
5773 {"flush", false, (test_callback_fn
*)flush_test
},
5774 {"init", false, (test_callback_fn
*)init_test
},
5775 {"allocation", false, (test_callback_fn
*)allocation_test
},
5776 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5777 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5778 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5779 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5780 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5781 {"clone_test", false, (test_callback_fn
*)clone_test
},
5782 {"connection_test", false, (test_callback_fn
*)connection_test
},
5783 {"callback_test", false, (test_callback_fn
*)callback_test
},
5784 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5785 {"set", false, (test_callback_fn
*)set_test
},
5786 {"set2", false, (test_callback_fn
*)set_test2
},
5787 {"set3", false, (test_callback_fn
*)set_test3
},
5788 {"dump", true, (test_callback_fn
*)dump_test
},
5789 {"add", true, (test_callback_fn
*)add_test
},
5790 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5791 {"replace", true, (test_callback_fn
*)replace_test
},
5792 {"delete", true, (test_callback_fn
*)delete_test
},
5793 {"get", true, (test_callback_fn
*)get_test
},
5794 {"get2", false, (test_callback_fn
*)get_test2
},
5795 {"get3", false, (test_callback_fn
*)get_test3
},
5796 {"get4", false, (test_callback_fn
*)get_test4
},
5797 {"partial mget", false, (test_callback_fn
*)get_test5
},
5798 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5799 {"increment", false, (test_callback_fn
*)increment_test
},
5800 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5801 {"decrement", false, (test_callback_fn
*)decrement_test
},
5802 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5803 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5804 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5805 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5806 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5807 {"binary_increment_with_prefix", 1, (test_callback_fn
*)binary_increment_with_prefix_test
},
5808 {"quit", false, (test_callback_fn
*)quit_test
},
5809 {"mget", true, (test_callback_fn
*)mget_test
},
5810 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5811 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5812 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5813 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5814 {"mget_end", false, (test_callback_fn
*)mget_end
},
5815 {"get_stats", false, (test_callback_fn
*)get_stats
},
5816 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5817 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5818 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5819 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
5820 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5821 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5822 {"read_through", true, (test_callback_fn
*)read_through
},
5823 {"delete_through", true, (test_callback_fn
*)delete_through
},
5824 {"noreply", true, (test_callback_fn
*)noreply_test
},
5825 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5826 {"connectionpool", true, (test_callback_fn
*)connection_pool_test
},
5827 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
5828 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
5829 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
5830 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
5831 {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_NOTFOUND
},
5832 {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_SUCCESS
},
5833 {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_by_key_NOTFOUND
},
5834 {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_by_key_SUCCESS
},
5838 test_st behavior_tests
[] ={
5839 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5840 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5841 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5842 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5843 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5844 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5845 {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test
},
5849 test_st libmemcachedutil_tests
[] ={
5850 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5851 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5852 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5856 test_st basic_tests
[] ={
5857 {"init", true, (test_callback_fn
*)basic_init_test
},
5858 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5859 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5860 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5861 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5862 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5863 {"memcached_return_t", false, (test_callback_fn
*)memcached_return_t_TEST
},
5867 test_st regression_binary_vs_block
[] ={
5868 {"block add", true, (test_callback_fn
*)block_add_regression
},
5869 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
5873 test_st async_tests
[] ={
5874 {"add", true, (test_callback_fn
*)add_wrapper
},
5878 test_st memcached_server_get_last_disconnect_tests
[] ={
5879 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
5880 {0, 0, (test_callback_fn
*)0}
5884 test_st result_tests
[] ={
5885 {"result static", false, (test_callback_fn
*)result_static
},
5886 {"result alloc", false, (test_callback_fn
*)result_alloc
},
5887 {0, 0, (test_callback_fn
*)0}
5890 test_st version_1_2_3
[] ={
5891 {"append", false, (test_callback_fn
*)append_test
},
5892 {"prepend", false, (test_callback_fn
*)prepend_test
},
5893 {"cas", false, (test_callback_fn
*)cas_test
},
5894 {"cas2", false, (test_callback_fn
*)cas2_test
},
5895 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
5896 {0, 0, (test_callback_fn
*)0}
5899 test_st haldenbrand_tests
[] ={
5900 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
5901 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
5902 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
5903 {0, 0, (test_callback_fn
*)0}
5906 test_st user_tests
[] ={
5907 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
5908 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
5909 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
5910 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
5911 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
5912 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
5913 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
5914 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
5915 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
5916 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
5917 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
5918 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
5919 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
5920 #if !defined(__sun) && !defined(__OpenBSD__)
5922 ** It seems to be something weird with the character sets..
5923 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5924 ** guess I need to find out how this is supposed to work.. Perhaps I need
5925 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5926 ** so just disable the code for now...).
5928 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
5930 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
5931 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
5932 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
5933 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
5934 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
5935 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
5936 {0, 0, (test_callback_fn
*)0}
5939 test_st replication_tests
[]= {
5940 {"set", true, (test_callback_fn
*)replication_set_test
},
5941 {"get", false, (test_callback_fn
*)replication_get_test
},
5942 {"mget", false, (test_callback_fn
*)replication_mget_test
},
5943 {"delete", true, (test_callback_fn
*)replication_delete_test
},
5944 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
5945 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
5946 {0, 0, (test_callback_fn
*)0}
5950 * The following test suite is used to verify that we don't introduce
5951 * regression bugs. If you want more information about the bug / test,
5952 * you should look in the bug report at
5953 * http://bugs.launchpad.net/libmemcached
5955 test_st regression_tests
[]= {
5956 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
5957 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
5958 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
5959 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
5960 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
5961 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
5962 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
5963 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
5964 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
5965 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
5966 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
5967 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
5968 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
5969 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
5970 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
5971 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
5972 {0, false, (test_callback_fn
*)0}
5975 test_st ketama_compatibility
[]= {
5976 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
5977 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
5978 {0, 0, (test_callback_fn
*)0}
5981 test_st generate_tests
[] ={
5982 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5983 {"generate_data", true, (test_callback_fn
*)generate_data
},
5984 {"get_read", false, (test_callback_fn
*)get_read
},
5985 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
5986 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5987 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
5988 {"generate_data", true, (test_callback_fn
*)generate_data
},
5989 {"mget_read", false, (test_callback_fn
*)mget_read
},
5990 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
5991 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
5992 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
5993 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
5994 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5995 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
5996 {"generate_data", true, (test_callback_fn
*)generate_data
},
5997 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5998 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5999 {0, 0, (test_callback_fn
*)0}
6002 test_st consistent_tests
[] ={
6003 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6004 {"generate_data", true, (test_callback_fn
*)generate_data
},
6005 {"get_read", 0, (test_callback_fn
*)get_read_count
},
6006 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6007 {0, 0, (test_callback_fn
*)0}
6010 test_st consistent_weighted_tests
[] ={
6011 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6012 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
6013 {"get_read", false, (test_callback_fn
*)get_read_count
},
6014 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6015 {0, 0, (test_callback_fn
*)0}
6018 test_st hsieh_availability
[] ={
6019 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
6020 {0, 0, (test_callback_fn
*)0}
6023 test_st murmur_availability
[] ={
6024 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
6025 {0, 0, (test_callback_fn
*)0}
6029 test_st hash_sanity
[] ={
6030 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
6031 {0, 0, (test_callback_fn
*)0}
6035 test_st ketama_auto_eject_hosts
[] ={
6036 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
6037 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
6038 {0, 0, (test_callback_fn
*)0}
6041 test_st hash_tests
[] ={
6042 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
6043 {"md5", false, (test_callback_fn
*)md5_run
},
6044 {"crc", false, (test_callback_fn
*)crc_run
},
6045 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
6046 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
6047 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
6048 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
6049 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
6050 {"murmur", false, (test_callback_fn
*)murmur_run
},
6051 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
6052 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
6053 {0, 0, (test_callback_fn
*)0}
6056 test_st error_conditions
[] ={
6057 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
6058 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
6059 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
6060 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6061 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6062 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
6063 {0, 0, (test_callback_fn
*)0}
6067 test_st parser_tests
[] ={
6068 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
6069 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
6070 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
6071 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
6072 {"hash", false, (test_callback_fn
*)parser_hash_test
},
6073 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
6074 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
6075 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
6076 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
6077 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
6078 {"server", false, (test_callback_fn
*)server_test
},
6079 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
6080 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
6081 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
6082 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
6083 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
6084 {0, 0, (test_callback_fn
*)0}
6087 test_st virtual_bucket_tests
[] ={
6088 {"basic", false, (test_callback_fn
*)virtual_back_map
},
6089 {0, 0, (test_callback_fn
*)0}
6092 test_st memcached_server_add_tests
[] ={
6093 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
6094 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
6095 {0, 0, (test_callback_fn
*)0}
6098 test_st namespace_tests
[] ={
6099 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
6100 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
6101 {0, 0, (test_callback_fn
*)0}
6104 collection_st collection
[] ={
6106 {"hash_sanity", 0, 0, hash_sanity
},
6108 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
6109 {"basic", 0, 0, basic_tests
},
6110 {"hsieh_availability", 0, 0, hsieh_availability
},
6111 {"murmur_availability", 0, 0, murmur_availability
},
6112 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
6113 {"block", 0, 0, tests
},
6114 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
6115 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
6116 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6117 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
6118 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
6119 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
6120 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
6121 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
6122 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
6123 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
6124 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
6125 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
6126 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
6127 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6128 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
6129 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6130 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
6131 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
6132 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
6133 #ifdef MEMCACHED_ENABLE_DEPRECATED
6134 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
6136 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
6137 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
6138 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
6139 {"specific namespace", 0, 0, namespace_tests
},
6140 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
6141 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
6142 {"result", 0, 0, result_tests
},
6143 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
6144 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
6145 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
6146 {"user written tests", 0, 0, user_tests
},
6147 {"generate", 0, 0, generate_tests
},
6148 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
6149 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
6150 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
6151 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
6152 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
6153 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
6154 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
6156 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
6157 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
6158 {"consistent_not", 0, 0, consistent_tests
},
6159 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
6160 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6161 {"ketama_compat", 0, 0, ketama_compatibility
},
6162 {"test_hashes", 0, 0, hash_tests
},
6163 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6164 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6165 {"regression", 0, 0, regression_tests
},
6166 {"behaviors", 0, 0, behavior_tests
},
6167 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6168 {"error_conditions", 0, 0, error_conditions
},
6169 {"parser", 0, 0, parser_tests
},
6170 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6171 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6175 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
6177 #include "tests/libmemcached_world.h"
6179 void get_world(Framework
*world
)
6181 world
->collections
= collection
;
6183 world
->_create
= (test_callback_create_fn
*)world_create
;
6184 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6186 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6187 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6188 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6189 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6190 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6192 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6193 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6195 world
->set_runner(&defualt_libmemcached_runner
);
6197 world
->set_socket();