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>
55 #include <semaphore.h>
59 #include <sys/types.h>
64 #include <libtest/server.h>
66 #include "clients/generator.h"
67 #include "clients/execute.h"
69 #define SMALL_STRING_LEN 1024
71 #include <libtest/test.hpp>
73 #include "tests/basic.h"
74 #include "tests/debug.h"
75 #include "tests/deprecated.h"
76 #include "tests/error_conditions.h"
77 #include "tests/exist.h"
78 #include "tests/ketama.h"
79 #include "tests/namespace.h"
80 #include "tests/parser.h"
81 #include "tests/pool.h"
82 #include "tests/print.h"
83 #include "tests/replication.h"
84 #include "tests/server_add.h"
85 #include "tests/virtual_buckets.h"
87 using namespace libtest
;
89 #include <libmemcached/memcached_util.h>
91 #include "hash_results.h"
93 #define GLOBAL_COUNT 10000
94 #define GLOBAL2_COUNT 100
95 #define SERVERS_TO_CREATE 5
96 static uint32_t global_count
;
98 static pairs_st
*global_pairs
;
99 static const char *global_keys
[GLOBAL_COUNT
];
100 static size_t global_keys_length
[GLOBAL_COUNT
];
103 static test_return_t
pre_binary(memcached_st
*memc
);
106 static test_return_t
init_test(memcached_st
*not_used
)
111 (void)memcached_create(&memc
);
112 memcached_free(&memc
);
117 #define TEST_PORT_COUNT 7
118 in_port_t test_ports
[TEST_PORT_COUNT
];
120 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
121 const memcached_server_st
*server
,
125 size_t bigger
= *((size_t *)(context
));
127 assert(bigger
<= memcached_server_port(server
));
128 *((size_t *)(context
))= memcached_server_port(server
);
130 return MEMCACHED_SUCCESS
;
133 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
134 const memcached_server_st
*instance
,
138 FILE *stream
= (FILE *)context
;
141 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
142 memcached_server_name(instance
),
143 memcached_server_port(instance
),
144 instance
->major_version
,
145 instance
->minor_version
,
146 instance
->micro_version
);
148 return MEMCACHED_SUCCESS
;
151 static test_return_t
server_sort_test(memcached_st
*ptr
)
153 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
155 memcached_return_t rc
;
156 memcached_server_fn callbacks
[1];
157 memcached_st
*local_memc
;
160 local_memc
= memcached_create(NULL
);
161 test_true(local_memc
);
162 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
164 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
166 test_ports
[x
]= (in_port_t
)random() % 64000;
167 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
168 test_compare(memcached_server_count(local_memc
), x
+1);
170 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
172 test_compare(MEMCACHED_SUCCESS
, rc
);
175 callbacks
[0]= server_display_function
;
176 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
179 memcached_free(local_memc
);
184 static test_return_t
server_sort2_test(memcached_st
*ptr
)
186 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
187 memcached_server_fn callbacks
[1];
188 memcached_st
*local_memc
;
189 memcached_server_instance_st instance
;
192 local_memc
= memcached_create(NULL
);
193 test_true(local_memc
);
194 test_compare(MEMCACHED_SUCCESS
,
195 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
197 test_compare(MEMCACHED_SUCCESS
,
198 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
199 instance
= memcached_server_instance_by_position(local_memc
, 0);
200 test_compare(in_port_t(43043), memcached_server_port(instance
));
202 test_compare(MEMCACHED_SUCCESS
,
203 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
205 instance
= memcached_server_instance_by_position(local_memc
, 0);
206 test_compare(in_port_t(43042), memcached_server_port(instance
));
208 instance
= memcached_server_instance_by_position(local_memc
, 1);
209 test_compare(in_port_t(43043), memcached_server_port(instance
));
211 callbacks
[0]= server_display_function
;
212 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
215 memcached_free(local_memc
);
220 static test_return_t
memcached_server_remove_test(memcached_st
*)
222 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";
225 test_compare(MEMCACHED_SUCCESS
,
226 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
227 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
230 memcached_server_fn callbacks
[1];
231 callbacks
[0]= server_print_callback
;
232 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
234 memcached_free(memc
);
239 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
240 const memcached_server_st
*server
,
244 uint32_t x
= *((uint32_t *)(context
));
246 if (! (test_ports
[x
] == server
->port
))
248 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
249 return MEMCACHED_FAILURE
;
252 *((uint32_t *)(context
))= ++x
;
254 return MEMCACHED_SUCCESS
;
257 static test_return_t
server_unsort_test(memcached_st
*ptr
)
259 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
260 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
261 memcached_server_fn callbacks
[1];
262 memcached_st
*local_memc
;
265 local_memc
= memcached_create(NULL
);
266 test_true(local_memc
);
268 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
270 test_ports
[x
]= (in_port_t
)(random() % 64000);
271 test_compare(MEMCACHED_SUCCESS
,
272 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
273 test_compare(memcached_server_count(local_memc
), x
+1);
275 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
279 callbacks
[0]= server_display_unsort_function
;
280 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
282 /* Now we sort old data! */
283 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
284 callbacks
[0]= server_display_function
;
285 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
288 memcached_free(local_memc
);
293 static test_return_t
allocation_test(memcached_st
*not_used
)
297 memc
= memcached_create(NULL
);
299 memcached_free(memc
);
304 static test_return_t
clone_test(memcached_st
*memc
)
308 memcached_st
*memc_clone
;
309 memc_clone
= memcached_clone(NULL
, NULL
);
310 test_true(memc_clone
);
311 memcached_free(memc_clone
);
314 /* Can we init from null? */
316 memcached_st
*memc_clone
;
317 memc_clone
= memcached_clone(NULL
, memc
);
318 test_true(memc_clone
);
321 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
322 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
323 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
324 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
327 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
328 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
329 test_true(memc_clone
->distribution
== memc
->distribution
);
330 { // Test all of the flags
331 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
332 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
333 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
334 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
335 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
336 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
337 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
338 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
339 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
340 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
341 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
342 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
343 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
345 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
346 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
347 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
348 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
349 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
350 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
351 test_true(memc_clone
->on_clone
== memc
->on_clone
);
352 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
353 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
354 test_true(memc_clone
->recv_size
== memc
->recv_size
);
355 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
356 test_true(memc_clone
->send_size
== memc
->send_size
);
357 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
358 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
359 test_true(memc_clone
->user_data
== memc
->user_data
);
361 memcached_free(memc_clone
);
364 /* Can we init from struct? */
366 memcached_st declared_clone
;
367 memcached_st
*memc_clone
;
368 memset(&declared_clone
, 0 , sizeof(memcached_st
));
369 memc_clone
= memcached_clone(&declared_clone
, NULL
);
370 test_true(memc_clone
);
371 memcached_free(memc_clone
);
374 /* Can we init from struct? */
376 memcached_st declared_clone
;
377 memcached_st
*memc_clone
;
378 memset(&declared_clone
, 0 , sizeof(memcached_st
));
379 memc_clone
= memcached_clone(&declared_clone
, memc
);
380 test_true(memc_clone
);
381 memcached_free(memc_clone
);
387 static test_return_t
userdata_test(memcached_st
*memc
)
390 test_false(memcached_set_user_data(memc
, foo
));
391 test_true(memcached_get_user_data(memc
) == foo
);
392 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
397 static test_return_t
connection_test(memcached_st
*memc
)
399 test_compare(MEMCACHED_SUCCESS
,
400 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
405 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
407 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
409 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
411 test_compare(36, int(MEMCACHED_BEHAVIOR_MAX
));
416 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
418 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
420 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
422 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
427 static test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
429 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
430 982370485U, 1263635348U, 4242906218U, 3829656100U,
431 1891735253U, 334139633U, 2257084983U, 3088286104U,
432 13199785U, 2542027183U, 1097051614U, 199566778U,
433 2748246961U, 2465192557U, 1664094137U, 2405439045U,
434 1842224848U, 692413798U, 3479807801U, 919913813U,
435 4269430871U, 610793021U, 527273862U, 1437122909U,
436 2300930706U, 2943759320U, 674306647U, 2400528935U,
437 54481931U, 4186304426U, 1741088401U, 2979625118U,
438 4159057246U, 3425930182U, 2593724503U, 1868899624U,
439 1769812374U, 2302537950U, 1110330676U, 3365377466U,
440 1336171666U, 3021258493U, 2334992265U, 3861994737U,
443 // You have updated the memcache_error messages but not updated docs/tests.
444 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
447 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
448 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
449 MEMCACHED_HASH_JENKINS
);
450 if (values
[rc
] != hash_val
)
452 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
453 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
455 test_compare(values
[rc
], hash_val
);
457 test_compare(48, int(MEMCACHED_MAXIMUM_RETURN
));
462 static test_return_t
set_test(memcached_st
*memc
)
464 memcached_return_t rc
= memcached_set(memc
,
465 test_literal_param("foo"),
466 test_literal_param("when we sanitize"),
467 time_t(0), (uint32_t)0);
468 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
473 static test_return_t
append_test(memcached_st
*memc
)
475 memcached_return_t rc
;
476 const char *key
= "fig";
477 const char *in_value
= "we";
478 char *out_value
= NULL
;
482 rc
= memcached_flush(memc
, 0);
483 test_compare(MEMCACHED_SUCCESS
, rc
);
485 rc
= memcached_set(memc
, key
, strlen(key
),
486 in_value
, strlen(in_value
),
487 (time_t)0, (uint32_t)0);
488 test_compare(MEMCACHED_SUCCESS
, rc
);
490 rc
= memcached_append(memc
, key
, strlen(key
),
491 " the", strlen(" the"),
492 (time_t)0, (uint32_t)0);
493 test_compare(MEMCACHED_SUCCESS
, rc
);
495 rc
= memcached_append(memc
, key
, strlen(key
),
496 " people", strlen(" people"),
497 (time_t)0, (uint32_t)0);
498 test_compare(MEMCACHED_SUCCESS
, rc
);
500 out_value
= memcached_get(memc
, key
, strlen(key
),
501 &value_length
, &flags
, &rc
);
502 test_memcmp(out_value
, "we the people", strlen("we the people"));
503 test_compare(strlen("we the people"), value_length
);
504 test_compare(MEMCACHED_SUCCESS
, rc
);
510 static test_return_t
append_binary_test(memcached_st
*memc
)
512 memcached_return_t rc
;
513 const char *key
= "numbers";
514 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
520 rc
= memcached_flush(memc
, 0);
521 test_compare(MEMCACHED_SUCCESS
, rc
);
523 rc
= memcached_set(memc
,
526 (time_t)0, (uint32_t)0);
527 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
529 for (x
= 0; store_list
[x
] ; x
++)
531 rc
= memcached_append(memc
,
533 (char *)&store_list
[x
], sizeof(uint32_t),
534 (time_t)0, (uint32_t)0);
535 test_compare(MEMCACHED_SUCCESS
, rc
);
538 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
539 &value_length
, &flags
, &rc
);
540 test_compare(value_length
, sizeof(uint32_t) * x
);
541 test_compare(MEMCACHED_SUCCESS
, rc
);
543 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
545 test_compare(*ptr
, store_list
[x
- counter
]);
553 static test_return_t
cas2_test(memcached_st
*memc
)
555 memcached_return_t rc
;
556 const char *keys
[]= {"fudge", "son", "food"};
557 size_t key_length
[]= {5, 3, 4};
558 const char *value
= "we the people";
559 size_t value_length
= strlen("we the people");
560 memcached_result_st results_obj
;
561 memcached_result_st
*results
;
564 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
566 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
568 for (uint32_t x
= 0; x
< 3; x
++)
570 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
571 keys
[x
], key_length
[x
],
572 (time_t)50, (uint32_t)9);
573 test_compare(MEMCACHED_SUCCESS
, rc
);
576 test_compare(MEMCACHED_SUCCESS
,
577 memcached_mget(memc
, keys
, key_length
, 3));
579 results
= memcached_result_create(memc
, &results_obj
);
582 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
584 test_true(results
->item_cas
);
585 test_compare(MEMCACHED_SUCCESS
, rc
);
586 test_true(memcached_result_cas(results
));
588 test_memcmp(value
, "we the people", strlen("we the people"));
589 test_compare(strlen("we the people"), value_length
);
590 test_compare(MEMCACHED_SUCCESS
, rc
);
592 memcached_result_free(&results_obj
);
597 static test_return_t
cas_test(memcached_st
*memc
)
599 memcached_return_t rc
;
600 const char *key
= "fun";
601 size_t key_length
= strlen(key
);
602 const char *value
= "we the people";
603 const char* keys
[2] = { key
, NULL
};
604 size_t keylengths
[2] = { strlen(key
), 0 };
605 size_t value_length
= strlen(value
);
606 const char *value2
= "change the value";
607 size_t value2_length
= strlen(value2
);
609 memcached_result_st results_obj
;
610 memcached_result_st
*results
;
613 rc
= memcached_flush(memc
, 0);
614 test_compare(MEMCACHED_SUCCESS
, rc
);
616 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
618 rc
= memcached_set(memc
, key
, strlen(key
),
619 value
, strlen(value
),
620 (time_t)0, (uint32_t)0);
621 test_compare(MEMCACHED_SUCCESS
, rc
);
623 test_compare(MEMCACHED_SUCCESS
,
624 memcached_mget(memc
, keys
, keylengths
, 1));
626 results
= memcached_result_create(memc
, &results_obj
);
629 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
631 test_compare(MEMCACHED_SUCCESS
, rc
);
632 test_true(memcached_result_cas(results
));
633 test_memcmp(value
, memcached_result_value(results
), value_length
);
634 test_compare(strlen(memcached_result_value(results
)), value_length
);
635 test_compare(MEMCACHED_SUCCESS
, rc
);
636 uint64_t cas
= memcached_result_cas(results
);
639 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
640 test_true(rc
== MEMCACHED_END
);
641 test_true(results
== NULL
);
644 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
645 test_compare(MEMCACHED_SUCCESS
, rc
);
648 * The item will have a new cas value, so try to set it again with the old
649 * value. This should fail!
651 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
652 test_compare(MEMCACHED_DATA_EXISTS
, rc
);
654 memcached_result_free(&results_obj
);
659 static test_return_t
prepend_test(memcached_st
*memc
)
661 memcached_return_t rc
;
662 const char *key
= "fig";
663 const char *value
= "people";
664 char *out_value
= NULL
;
668 rc
= memcached_flush(memc
, 0);
669 test_compare(MEMCACHED_SUCCESS
, rc
);
671 rc
= memcached_set(memc
, key
, strlen(key
),
672 value
, strlen(value
),
673 (time_t)0, (uint32_t)0);
674 test_compare(MEMCACHED_SUCCESS
, rc
);
676 rc
= memcached_prepend(memc
, key
, strlen(key
),
677 "the ", strlen("the "),
678 (time_t)0, (uint32_t)0);
679 test_compare(MEMCACHED_SUCCESS
, rc
);
681 rc
= memcached_prepend(memc
, key
, strlen(key
),
682 "we ", strlen("we "),
683 (time_t)0, (uint32_t)0);
684 test_compare(MEMCACHED_SUCCESS
, rc
);
686 out_value
= memcached_get(memc
, key
, strlen(key
),
687 &value_length
, &flags
, &rc
);
688 test_memcmp(out_value
, "we the people", strlen("we the people"));
689 test_compare(strlen("we the people"), value_length
);
690 test_compare(MEMCACHED_SUCCESS
, rc
);
697 Set the value, then quit to make sure it is flushed.
698 Come back in and test that add fails.
700 static test_return_t
add_test(memcached_st
*memc
)
702 memcached_return_t rc
;
703 const char *key
= "foo";
704 const char *value
= "when we sanitize";
705 unsigned long long setting_value
;
707 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
709 rc
= memcached_set(memc
, key
, strlen(key
),
710 value
, strlen(value
),
711 (time_t)0, (uint32_t)0);
712 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
713 memcached_quit(memc
);
714 rc
= memcached_add(memc
, key
, strlen(key
),
715 value
, strlen(value
),
716 (time_t)0, (uint32_t)0);
718 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
721 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
725 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
732 ** There was a problem of leaking filedescriptors in the initial release
733 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
734 ** systems it seems that the kernel is slow on reclaiming the resources
735 ** because the connects starts to time out (the test doesn't do much
736 ** anyway, so just loop 10 iterations)
738 static test_return_t
add_wrapper(memcached_st
*memc
)
740 unsigned int max
= 10000;
748 for (uint32_t x
= 0; x
< max
; x
++)
754 static test_return_t
replace_test(memcached_st
*memc
)
756 memcached_return_t rc
;
757 const char *key
= "foo";
758 const char *value
= "when we sanitize";
759 const char *original
= "first we insert some data";
761 rc
= memcached_set(memc
, key
, strlen(key
),
762 original
, strlen(original
),
763 (time_t)0, (uint32_t)0);
764 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
766 test_compare(MEMCACHED_SUCCESS
,
767 memcached_replace(memc
, key
, strlen(key
),
768 value
, strlen(value
),
769 (time_t)0, (uint32_t)0));
774 static test_return_t
delete_test(memcached_st
*memc
)
776 memcached_return_t rc
;
777 const char *key
= "foo";
778 const char *value
= "when we sanitize";
780 rc
= memcached_set(memc
, key
, strlen(key
),
781 value
, strlen(value
),
782 (time_t)0, (uint32_t)0);
783 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
785 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
786 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
791 static test_return_t
flush_test(memcached_st
*memc
)
793 uint64_t query_id
= memcached_query_id(memc
);
794 test_compare(MEMCACHED_SUCCESS
,
795 memcached_flush(memc
, 0));
796 test_compare(query_id
+1, memcached_query_id(memc
));
801 static memcached_return_t
server_function(const memcached_st
*ptr
,
802 const memcached_server_st
*server
,
805 (void)ptr
; (void)server
; (void)context
;
808 return MEMCACHED_SUCCESS
;
811 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
814 strncpy(context
, "foo bad", sizeof(context
));
815 memcached_server_fn callbacks
[1];
817 callbacks
[0]= server_function
;
818 memcached_server_cursor(memc
, callbacks
, context
, 1);
822 static test_return_t
bad_key_test(memcached_st
*memc
)
824 memcached_return_t rc
;
825 const char *key
= "foo bad";
827 memcached_st
*memc_clone
;
829 uint64_t query_id
= memcached_query_id(memc
);
831 // Just skip if we are in binary mode.
832 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
834 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
836 memc_clone
= memcached_clone(NULL
, memc
);
837 test_true(memc_clone
);
839 query_id
= memcached_query_id(memc_clone
);
840 test_compare(MEMCACHED_SUCCESS
,
841 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
842 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
844 /* All keys are valid in the binary protocol (except for length) */
845 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
847 uint64_t before_query_id
= memcached_query_id(memc_clone
);
849 size_t string_length
;
850 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
851 &string_length
, &flags
, &rc
);
852 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
853 test_zero(string_length
);
856 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
858 query_id
= memcached_query_id(memc_clone
);
859 test_compare(MEMCACHED_SUCCESS
,
860 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
861 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
863 size_t string_length
;
864 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
865 &string_length
, &flags
, &rc
);
866 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
867 test_zero(string_length
);
871 /* Test multi key for bad keys */
872 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
873 size_t key_lengths
[] = { 7, 7, 7 };
874 query_id
= memcached_query_id(memc_clone
);
875 test_compare(MEMCACHED_SUCCESS
,
876 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
877 test_compare(query_id
, memcached_query_id(memc_clone
));
879 query_id
= memcached_query_id(memc_clone
);
880 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
881 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
882 test_compare(query_id
+1, memcached_query_id(memc_clone
));
884 query_id
= memcached_query_id(memc_clone
);
885 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
886 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
887 test_compare(query_id
+1, memcached_query_id(memc_clone
));
889 /* The following test should be moved to the end of this function when the
890 memcached server is updated to allow max size length of the keys in the
893 test_compare(MEMCACHED_SUCCESS
,
894 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
896 std::vector
<char> longkey
;
897 longkey
.insert(longkey
.end(), MEMCACHED_MAX_KEY
, 'a');
898 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
900 size_t string_length
;
902 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
903 test_compare(MEMCACHED_NOTFOUND
, rc
);
904 test_zero(string_length
);
906 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
907 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
908 test_zero(string_length
);
912 /* Make sure zero length keys are marked as bad */
914 test_compare(MEMCACHED_SUCCESS
,
915 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
916 size_t string_length
;
917 char *string
= memcached_get(memc_clone
, key
, 0,
918 &string_length
, &flags
, &rc
);
919 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
920 test_zero(string_length
);
924 memcached_free(memc_clone
);
929 #define READ_THROUGH_VALUE "set for me"
930 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
933 memcached_result_st
*result
)
935 (void)memc
;(void)key
;(void)key_length
;
936 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
939 #ifndef __INTEL_COMPILER
940 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
943 static test_return_t
read_through(memcached_st
*memc
)
945 memcached_return_t rc
;
946 const char *key
= "foo";
948 size_t string_length
;
950 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
952 string
= memcached_get(memc
, key
, strlen(key
),
953 &string_length
, &flags
, &rc
);
955 test_compare(MEMCACHED_NOTFOUND
, rc
);
956 test_false(string_length
);
959 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
);
960 test_compare(MEMCACHED_SUCCESS
, rc
);
962 string
= memcached_get(memc
, key
, strlen(key
),
963 &string_length
, &flags
, &rc
);
965 test_compare(MEMCACHED_SUCCESS
, rc
);
966 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
967 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
968 test_strcmp(READ_THROUGH_VALUE
, string
);
971 string
= memcached_get(memc
, key
, strlen(key
),
972 &string_length
, &flags
, &rc
);
974 test_compare(MEMCACHED_SUCCESS
, rc
);
976 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
977 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
978 test_strcmp(READ_THROUGH_VALUE
, string
);
984 static memcached_return_t
delete_trigger(memcached_st
*,
991 return MEMCACHED_SUCCESS
;
994 static test_return_t
delete_through(memcached_st
*memc
)
996 memcached_trigger_delete_key_fn callback
;
998 callback
= (memcached_trigger_delete_key_fn
)delete_trigger
;
1000 test_compare(MEMCACHED_SUCCESS
,
1001 memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
));
1003 return TEST_SUCCESS
;
1006 static test_return_t
get_test(memcached_st
*memc
)
1008 memcached_return_t rc
;
1009 const char *key
= "foo";
1011 size_t string_length
;
1014 uint64_t query_id
= memcached_query_id(memc
);
1015 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
1016 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
1017 test_compare(query_id
+1, memcached_query_id(memc
));
1019 string
= memcached_get(memc
, key
, strlen(key
),
1020 &string_length
, &flags
, &rc
);
1022 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1023 test_false(string_length
);
1026 return TEST_SUCCESS
;
1029 static test_return_t
get_test2(memcached_st
*memc
)
1031 const char *key
= "foo";
1032 const char *value
= "when we sanitize";
1034 uint64_t query_id
= memcached_query_id(memc
);
1035 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1036 value
, strlen(value
),
1037 (time_t)0, (uint32_t)0);
1038 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1039 test_compare(query_id
+1, memcached_query_id(memc
));
1041 query_id
= memcached_query_id(memc
);
1042 test_true(query_id
);
1045 size_t string_length
;
1046 char *string
= memcached_get(memc
, key
, strlen(key
),
1047 &string_length
, &flags
, &rc
);
1048 test_compare(query_id
+1, memcached_query_id(memc
));
1050 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1051 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1053 test_compare(strlen(value
), string_length
);
1054 test_memcmp(string
, value
, string_length
);
1058 return TEST_SUCCESS
;
1061 static test_return_t
set_test2(memcached_st
*memc
)
1063 const char *key
= "foo";
1064 const char *value
= "train in the brain";
1065 size_t value_length
= strlen(value
);
1067 for (uint32_t x
= 0; x
< 10; x
++)
1069 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1070 value
, value_length
,
1071 (time_t)0, (uint32_t)0);
1072 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1075 return TEST_SUCCESS
;
1078 static test_return_t
set_test3(memcached_st
*memc
)
1080 size_t value_length
= 8191;
1082 char *value
= (char*)malloc(value_length
);
1085 for (uint32_t x
= 0; x
< value_length
; x
++)
1087 value
[x
] = (char) (x
% 127);
1090 /* The dump test relies on there being at least 32 items in memcached */
1091 for (uint32_t x
= 0; x
< 32; x
++)
1095 snprintf(key
, sizeof(key
), "foo%u", x
);
1097 uint64_t query_id
= memcached_query_id(memc
);
1098 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1099 value
, value_length
,
1100 (time_t)0, (uint32_t)0);
1101 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1102 test_compare(query_id
+1, memcached_query_id(memc
));
1107 return TEST_SUCCESS
;
1110 static test_return_t
get_test3(memcached_st
*memc
)
1112 const char *key
= "foo";
1113 size_t value_length
= 8191;
1115 char *value
= (char*)malloc(value_length
);
1118 for (uint32_t x
= 0; x
< value_length
; x
++)
1120 value
[x
] = (char) (x
% 127);
1123 memcached_return_t rc
;
1124 rc
= memcached_set(memc
, key
, strlen(key
),
1125 value
, value_length
,
1126 (time_t)0, (uint32_t)0);
1127 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1129 size_t string_length
;
1131 char *string
= memcached_get(memc
, key
, strlen(key
),
1132 &string_length
, &flags
, &rc
);
1134 test_compare(MEMCACHED_SUCCESS
, rc
);
1136 test_compare(string_length
, value_length
);
1137 test_memcmp(string
, value
, string_length
);
1142 return TEST_SUCCESS
;
1145 static test_return_t
get_test4(memcached_st
*memc
)
1147 const char *key
= "foo";
1148 size_t value_length
= 8191;
1150 char *value
= (char*)malloc(value_length
);
1153 for (uint32_t x
= 0; x
< value_length
; x
++)
1155 value
[x
] = (char) (x
% 127);
1158 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1159 value
, value_length
,
1160 (time_t)0, (uint32_t)0);
1161 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1163 for (uint32_t x
= 0; x
< 10; x
++)
1166 size_t string_length
;
1167 char *string
= memcached_get(memc
, key
, strlen(key
),
1168 &string_length
, &flags
, &rc
);
1170 test_compare(MEMCACHED_SUCCESS
, rc
);
1172 test_compare(string_length
, value_length
);
1173 test_memcmp(string
, value
, string_length
);
1179 return TEST_SUCCESS
;
1183 * This test verifies that memcached_read_one_response doesn't try to
1184 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1185 * responses before you execute a storage command.
1187 static test_return_t
get_test5(memcached_st
*memc
)
1190 ** Request the same key twice, to ensure that we hash to the same server
1191 ** (so that we have multiple response values queued up) ;-)
1193 const char *keys
[]= { "key", "key" };
1194 size_t lengths
[]= { 3, 3 };
1198 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1199 keys
[0], lengths
[0], 0, 0);
1200 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1202 memcached_result_st results_obj
;
1203 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1206 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1209 memcached_result_free(&results_obj
);
1211 /* Don't read out the second result, but issue a set instead.. */
1212 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1214 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1215 &rlen
, &flags
, &rc
);
1217 test_compare(MEMCACHED_NOTFOUND
, rc
);
1218 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1220 test_compare(MEMCACHED_SUCCESS
, rc
);
1223 return TEST_SUCCESS
;
1226 static test_return_t
mget_end(memcached_st
*memc
)
1228 const char *keys
[]= { "foo", "foo2" };
1229 size_t lengths
[]= { 3, 4 };
1230 const char *values
[]= { "fjord", "41" };
1232 memcached_return_t rc
;
1235 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1237 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[x
], lengths
[x
], values
[x
], strlen(values
[x
]), (time_t)0, (uint32_t)0));
1241 size_t string_length
;
1244 // retrieve both via mget
1245 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1247 char key
[MEMCACHED_MAX_KEY
];
1250 // this should get both
1251 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1253 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1255 test_compare(MEMCACHED_SUCCESS
, rc
);
1257 if (key_length
== 4)
1262 test_compare(string_length
, strlen(values
[val
]));
1263 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1267 // this should indicate end
1268 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1269 test_compare(MEMCACHED_END
, rc
);
1273 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1274 test_compare(MEMCACHED_SUCCESS
, rc
);
1276 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1277 test_compare(key_length
, lengths
[0]);
1278 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1279 test_compare(string_length
, strlen(values
[0]));
1280 test_true(strncmp(values
[0], string
, string_length
) == 0);
1281 test_compare(MEMCACHED_SUCCESS
, rc
);
1284 // this should indicate end
1285 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1286 test_compare(MEMCACHED_END
, rc
);
1289 return TEST_SUCCESS
;
1292 /* Do not copy the style of this code, I just access hosts to testthis function */
1293 static test_return_t
stats_servername_test(memcached_st
*memc
)
1295 memcached_stat_st memc_stat
;
1296 memcached_server_instance_st instance
=
1297 memcached_server_instance_by_position(memc
, 0);
1299 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1301 return TEST_SKIPPED
;
1304 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1305 memcached_server_name(instance
),
1306 memcached_server_port(instance
)));
1308 return TEST_SUCCESS
;
1311 static test_return_t
increment_test(memcached_st
*memc
)
1313 uint64_t new_number
;
1315 test_compare(MEMCACHED_SUCCESS
,
1317 test_literal_param("number"),
1318 test_literal_param("0"),
1319 (time_t)0, (uint32_t)0));
1321 test_compare(MEMCACHED_SUCCESS
,
1322 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1323 test_compare(uint64_t(1), new_number
);
1325 test_compare(MEMCACHED_SUCCESS
,
1326 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1327 test_compare(uint64_t(2), new_number
);
1329 return TEST_SUCCESS
;
1332 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1334 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1336 uint64_t new_number
;
1337 uint64_t initial
= 0;
1339 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1341 test_compare(MEMCACHED_SUCCESS
,
1342 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1343 test_compare(new_number
, initial
);
1345 test_compare(MEMCACHED_SUCCESS
,
1346 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1347 test_compare(new_number
, (initial
+1));
1349 return TEST_SUCCESS
;
1352 static test_return_t
decrement_test(memcached_st
*memc
)
1354 uint64_t new_number
;
1355 memcached_return_t rc
;
1356 const char *value
= "3";
1358 rc
= memcached_set(memc
,
1359 test_literal_param("number"),
1360 value
, strlen(value
),
1361 (time_t)0, (uint32_t)0);
1362 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1364 test_compare(MEMCACHED_SUCCESS
,
1365 memcached_decrement(memc
,
1366 test_literal_param("number"),
1368 test_compare(uint64_t(2), new_number
);
1370 test_compare(MEMCACHED_SUCCESS
,
1371 memcached_decrement(memc
,
1372 test_literal_param("number"),
1374 test_compare(uint64_t(1), new_number
);
1376 return TEST_SUCCESS
;
1379 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1381 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1383 uint64_t new_number
;
1384 uint64_t initial
= 3;
1386 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
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
);
1394 test_compare(MEMCACHED_SUCCESS
,
1395 memcached_decrement_with_initial(memc
,
1396 test_literal_param("number"),
1397 1, initial
, 0, &new_number
));
1398 test_compare(new_number
, (initial
- 1));
1400 return TEST_SUCCESS
;
1403 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1405 uint64_t new_number
;
1406 memcached_return_t rc
;
1407 const char *master_key
= "foo";
1408 const char *key
= "number";
1409 const char *value
= "0";
1411 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1413 value
, strlen(value
),
1414 (time_t)0, (uint32_t)0);
1415 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1417 test_compare(MEMCACHED_SUCCESS
,
1418 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1419 test_compare(uint64_t(1), new_number
);
1421 test_compare(MEMCACHED_SUCCESS
,
1422 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1423 test_compare(uint64_t(2), new_number
);
1425 return TEST_SUCCESS
;
1428 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1430 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1432 uint64_t new_number
;
1433 memcached_return_t rc
;
1434 const char *master_key
= "foo";
1435 const char *key
= "number";
1436 uint64_t initial
= 0;
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
);
1444 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1446 1, initial
, 0, &new_number
);
1447 test_compare(MEMCACHED_SUCCESS
, rc
);
1448 test_compare(new_number
, (initial
+1));
1450 return TEST_SUCCESS
;
1453 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1455 uint64_t new_number
;
1456 memcached_return_t rc
;
1457 const char *value
= "3";
1459 rc
= memcached_set_by_key(memc
,
1460 test_literal_param("foo"),
1461 test_literal_param("number"),
1462 value
, strlen(value
),
1463 (time_t)0, (uint32_t)0);
1464 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1466 test_compare(MEMCACHED_SUCCESS
,
1467 memcached_decrement_by_key(memc
,
1468 test_literal_param("foo"),
1469 test_literal_param("number"),
1471 test_compare(uint64_t(2), new_number
);
1473 test_compare(MEMCACHED_SUCCESS
,
1474 memcached_decrement_by_key(memc
,
1475 test_literal_param("foo"),
1476 test_literal_param("number"),
1478 test_compare(uint64_t(1), new_number
);
1480 return TEST_SUCCESS
;
1483 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1485 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1487 uint64_t new_number
;
1488 uint64_t initial
= 3;
1490 test_compare(MEMCACHED_SUCCESS
,
1491 memcached_decrement_with_initial_by_key(memc
,
1492 test_literal_param("foo"),
1493 test_literal_param("number"),
1494 1, initial
, 0, &new_number
));
1495 test_compare(new_number
, initial
);
1497 test_compare(MEMCACHED_SUCCESS
,
1498 memcached_decrement_with_initial_by_key(memc
,
1499 test_literal_param("foo"),
1500 test_literal_param("number"),
1501 1, initial
, 0, &new_number
));
1502 test_compare(new_number
, (initial
- 1));
1504 return TEST_SUCCESS
;
1506 static test_return_t
binary_increment_with_prefix_test(memcached_st
*orig_memc
)
1508 memcached_st
*memc
= memcached_clone(NULL
, orig_memc
);
1510 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1512 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1514 memcached_return_t rc
;
1515 rc
= memcached_set(memc
,
1516 test_literal_param("number"),
1517 test_literal_param("0"),
1518 (time_t)0, (uint32_t)0);
1519 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1521 uint64_t new_number
;
1522 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1523 test_literal_param("number"),
1525 test_compare(uint64_t(1), new_number
);
1527 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1528 test_literal_param("number"),
1530 test_compare(uint64_t(2), new_number
);
1531 memcached_free(memc
);
1533 return TEST_SUCCESS
;
1536 static test_return_t
quit_test(memcached_st
*memc
)
1538 memcached_return_t rc
;
1539 const char *key
= "fudge";
1540 const char *value
= "sanford and sun";
1542 rc
= memcached_set(memc
, key
, strlen(key
),
1543 value
, strlen(value
),
1544 (time_t)10, (uint32_t)3);
1545 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1546 memcached_quit(memc
);
1548 rc
= memcached_set(memc
, key
, strlen(key
),
1549 value
, strlen(value
),
1550 (time_t)50, (uint32_t)9);
1551 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1553 return TEST_SUCCESS
;
1556 static test_return_t
mget_result_test(memcached_st
*memc
)
1558 const char *keys
[]= {"fudge", "son", "food"};
1559 size_t key_length
[]= {5, 3, 4};
1561 memcached_result_st results_obj
;
1562 memcached_result_st
*results
;
1564 results
= memcached_result_create(memc
, &results_obj
);
1566 test_true(&results_obj
== results
);
1568 /* We need to empty the server before continueing test */
1569 test_compare(MEMCACHED_SUCCESS
,
1570 memcached_flush(memc
, 0));
1572 test_compare(MEMCACHED_SUCCESS
,
1573 memcached_mget(memc
, keys
, key_length
, 3));
1575 memcached_return_t rc
;
1576 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1581 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1582 test_false(results
);
1583 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1585 for (uint32_t x
= 0; x
< 3; x
++)
1587 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1588 keys
[x
], key_length
[x
],
1589 (time_t)50, (uint32_t)9);
1590 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1593 test_compare(MEMCACHED_SUCCESS
,
1594 memcached_mget(memc
, keys
, key_length
, 3));
1596 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1599 test_true(&results_obj
== results
);
1600 test_compare(MEMCACHED_SUCCESS
, rc
);
1601 test_memcmp(memcached_result_key_value(results
),
1602 memcached_result_value(results
),
1603 memcached_result_length(results
));
1604 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1607 memcached_result_free(&results_obj
);
1609 return TEST_SUCCESS
;
1612 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1614 const char *keys
[]= {"fudge", "son", "food"};
1615 size_t key_length
[]= {5, 3, 4};
1617 memcached_result_st
*results
;
1619 /* We need to empty the server before continueing test */
1620 test_compare(MEMCACHED_SUCCESS
,
1621 memcached_flush(memc
, 0));
1623 test_compare(MEMCACHED_SUCCESS
,
1624 memcached_mget(memc
, keys
, key_length
, 3));
1626 memcached_return_t rc
;
1627 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1631 test_false(results
);
1632 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1634 for (uint32_t x
= 0; x
< 3; x
++)
1636 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1637 keys
[x
], key_length
[x
],
1638 (time_t)50, (uint32_t)9);
1639 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1642 test_compare(MEMCACHED_SUCCESS
,
1643 memcached_mget(memc
, keys
, key_length
, 3));
1646 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1649 test_compare(MEMCACHED_SUCCESS
, rc
);
1650 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1651 test_memcmp(memcached_result_key_value(results
),
1652 memcached_result_value(results
),
1653 memcached_result_length(results
));
1654 memcached_result_free(results
);
1658 return TEST_SUCCESS
;
1661 /* Count the results */
1662 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1664 size_t *counter
= (size_t *)context
;
1666 *counter
= *counter
+ 1;
1668 return MEMCACHED_SUCCESS
;
1671 static test_return_t
mget_result_function(memcached_st
*memc
)
1673 const char *keys
[]= {"fudge", "son", "food"};
1674 size_t key_length
[]= {5, 3, 4};
1676 memcached_execute_fn callbacks
[1];
1678 /* We need to empty the server before continueing test */
1679 test_compare(MEMCACHED_SUCCESS
,
1680 memcached_flush(memc
, 0));
1681 for (uint32_t x
= 0; x
< 3; x
++)
1683 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1684 keys
[x
], key_length
[x
],
1685 (time_t)50, (uint32_t)9);
1686 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1689 test_compare(MEMCACHED_SUCCESS
,
1690 memcached_mget(memc
, keys
, key_length
, 3));
1692 callbacks
[0]= &callback_counter
;
1695 test_compare(MEMCACHED_SUCCESS
,
1696 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1698 test_compare(size_t(3), counter
);
1700 return TEST_SUCCESS
;
1703 static test_return_t
mget_test(memcached_st
*memc
)
1705 const char *keys
[]= {"fudge", "son", "food"};
1706 size_t key_length
[]= {5, 3, 4};
1708 char return_key
[MEMCACHED_MAX_KEY
];
1709 size_t return_key_length
;
1711 size_t return_value_length
;
1713 /* We need to empty the server before continueing test */
1714 test_compare(MEMCACHED_SUCCESS
,
1715 memcached_flush(memc
, 0));
1717 test_compare(MEMCACHED_SUCCESS
,
1718 memcached_mget(memc
, keys
, key_length
, 3));
1721 memcached_return_t rc
;
1722 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1723 &return_value_length
, &flags
, &rc
)))
1725 test_true(return_value
);
1727 test_false(return_value
);
1728 test_zero(return_value_length
);
1729 test_compare(MEMCACHED_NOTFOUND
, rc
);
1731 for (uint32_t x
= 0; x
< 3; x
++)
1733 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1734 keys
[x
], key_length
[x
],
1735 (time_t)50, (uint32_t)9);
1736 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1738 test_compare(MEMCACHED_SUCCESS
,
1739 memcached_mget(memc
, keys
, key_length
, 3));
1742 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1743 &return_value_length
, &flags
, &rc
)))
1745 test_true(return_value
);
1746 test_compare(MEMCACHED_SUCCESS
, rc
);
1747 if (not memc
->_namespace
)
1749 test_compare(return_key_length
, return_value_length
);
1750 test_memcmp(return_value
, return_key
, return_value_length
);
1756 return TEST_SUCCESS
;
1759 static test_return_t
mget_execute(memcached_st
*memc
)
1763 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1767 * I only want to hit _one_ server so I know the number of requests I'm
1768 * sending in the pipeline.
1770 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1771 memc
->number_of_hosts
= 1;
1773 size_t max_keys
= 20480;
1776 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1777 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1779 /* First add all of the items.. */
1780 char blob
[1024] = {0};
1781 memcached_return_t rc
;
1783 for (size_t x
= 0; x
< max_keys
; ++x
)
1787 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1789 test_true(keys
[x
] != NULL
);
1790 uint64_t query_id
= memcached_query_id(memc
);
1791 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1792 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1793 test_compare(query_id
+1, memcached_query_id(memc
));
1796 /* Try to get all of them with a large multiget */
1798 memcached_execute_fn callbacks
[]= { &callback_counter
};
1799 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1800 max_keys
, callbacks
, &counter
, 1);
1802 if (memcached_success(rc
))
1805 uint64_t query_id
= memcached_query_id(memc
);
1806 test_compare(MEMCACHED_SUCCESS
,
1807 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1808 test_compare(query_id
, memcached_query_id(memc
));
1810 /* Verify that we got all of the items */
1811 test_true(counter
== max_keys
);
1813 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1815 test_true(counter
== 0);
1819 test_fail("note: this test functions differently when in binary mode");
1822 /* Release all allocated resources */
1823 for (size_t x
= 0; x
< max_keys
; ++x
)
1830 memc
->number_of_hosts
= number_of_hosts
;
1831 return TEST_SUCCESS
;
1834 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1836 static test_return_t
key_setup(memcached_st
*memc
)
1838 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1840 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1842 return TEST_SUCCESS
;
1845 static test_return_t
key_teardown(memcached_st
*memc
)
1848 pairs_free(global_pairs
);
1850 return TEST_SUCCESS
;
1853 static test_return_t
block_add_regression(memcached_st
*memc
)
1855 /* First add all of the items.. */
1856 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1858 memcached_return_t rc
;
1859 char blob
[1024] = {0};
1861 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1862 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1865 return TEST_SUCCESS
;
1868 static test_return_t
binary_add_regression(memcached_st
*memc
)
1870 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1871 test_return_t rc
= block_add_regression(memc
);
1872 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1876 static test_return_t
get_stats_keys(memcached_st
*memc
)
1880 memcached_stat_st memc_stat
;
1881 memcached_return_t rc
;
1883 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1884 test_compare(MEMCACHED_SUCCESS
, rc
);
1885 for (ptr
= stat_list
; *ptr
; ptr
++)
1890 return TEST_SUCCESS
;
1893 static test_return_t
version_string_test(memcached_st
*memc
)
1895 const char *version_string
;
1898 version_string
= memcached_lib_version();
1900 test_strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
);
1902 return TEST_SUCCESS
;
1905 static test_return_t
get_stats(memcached_st
*memc
)
1907 memcached_return_t rc
;
1909 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1910 test_compare(MEMCACHED_SUCCESS
, rc
);
1911 test_true(memc_stat
);
1913 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1915 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1916 test_compare(MEMCACHED_SUCCESS
, rc
);
1917 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1922 memcached_stat_free(NULL
, memc_stat
);
1924 return TEST_SUCCESS
;
1927 static test_return_t
add_host_test(memcached_st
*memc
)
1930 memcached_server_st
*servers
;
1931 memcached_return_t rc
;
1932 char servername
[]= "0.example.com";
1934 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1936 test_true(1 == memcached_server_list_count(servers
));
1938 for (x
= 2; x
< 20; x
++)
1940 char buffer
[SMALL_STRING_LEN
];
1942 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1943 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1945 test_compare(MEMCACHED_SUCCESS
, rc
);
1946 test_true(x
== memcached_server_list_count(servers
));
1949 rc
= memcached_server_push(memc
, servers
);
1950 test_compare(MEMCACHED_SUCCESS
, rc
);
1951 rc
= memcached_server_push(memc
, servers
);
1952 test_compare(MEMCACHED_SUCCESS
, rc
);
1954 memcached_server_list_free(servers
);
1956 return TEST_SUCCESS
;
1959 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1961 memcached_return_t rc
;
1962 const char *key
= "not_found";
1963 size_t key_len
= strlen(key
);
1965 test_compare(MEMCACHED_SUCCESS
,
1966 memcached_mget(memc
, &key
, &key_len
, 1));
1968 memcached_result_st
*result
= NULL
;
1969 result
= memcached_fetch_result(memc
, result
, &rc
);
1971 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1973 memcached_result_free(result
);
1975 return TEST_SUCCESS
;
1978 static memcached_return_t
clone_test_callback(memcached_st
*parent
, memcached_st
*memc_clone
)
1980 (void)parent
;(void)memc_clone
;
1981 return MEMCACHED_SUCCESS
;
1984 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
)
1987 return MEMCACHED_SUCCESS
;
1990 static test_return_t
callback_test(memcached_st
*memc
)
1992 /* Test User Data */
1996 memcached_return_t rc
;
1998 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1999 test_compare(MEMCACHED_SUCCESS
, rc
);
2000 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
2001 test_true(*test_ptr
== x
);
2004 /* Test Clone Callback */
2006 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2007 void *clone_cb_ptr
= *(void **)&clone_cb
;
2008 void *temp_function
= NULL
;
2009 memcached_return_t rc
;
2011 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2013 test_compare(MEMCACHED_SUCCESS
, rc
);
2014 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2015 test_true(temp_function
== clone_cb_ptr
);
2018 /* Test Cleanup Callback */
2020 memcached_cleanup_fn cleanup_cb
=
2021 (memcached_cleanup_fn
)cleanup_test_callback
;
2022 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2023 void *temp_function
= NULL
;
2024 memcached_return_t rc
;
2026 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2028 test_compare(MEMCACHED_SUCCESS
, rc
);
2029 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2030 test_true(temp_function
== cleanup_cb_ptr
);
2033 return TEST_SUCCESS
;
2036 /* We don't test the behavior itself, we test the switches */
2037 static test_return_t
behavior_test(memcached_st
*memc
)
2042 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2043 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2044 test_true(value
== 1);
2046 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2047 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2048 test_true(value
== 1);
2050 set
= MEMCACHED_HASH_MD5
;
2051 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2052 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2053 test_true(value
== MEMCACHED_HASH_MD5
);
2057 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2058 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2059 test_true(value
== 0);
2061 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2062 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2063 test_true(value
== 0);
2065 set
= MEMCACHED_HASH_DEFAULT
;
2066 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2067 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2068 test_true(value
== MEMCACHED_HASH_DEFAULT
);
2070 set
= MEMCACHED_HASH_CRC
;
2071 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2072 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2073 test_true(value
== MEMCACHED_HASH_CRC
);
2075 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2076 test_true(value
> 0);
2078 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2079 test_true(value
> 0);
2081 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2082 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
2083 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2085 return TEST_SUCCESS
;
2088 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2090 memcached_return_t rc
;
2093 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
2094 test_true(rc
== MEMCACHED_DEPRECATED
);
2096 // Platform dependent
2098 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2102 return TEST_SUCCESS
;
2106 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2108 memcached_return_t rc
;
2112 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, set
);
2113 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2115 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2117 if (rc
== MEMCACHED_SUCCESS
)
2119 test_true((bool)value
== set
);
2123 test_false((bool)value
== set
);
2126 return TEST_SUCCESS
;
2130 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2132 memcached_return_t rc
;
2136 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, set
);
2137 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2139 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2141 if (rc
== MEMCACHED_SUCCESS
)
2143 test_true((bool)value
== set
);
2147 test_false((bool)value
== set
);
2150 return TEST_SUCCESS
;
2153 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, const memcached_return_t expect
)
2155 memcached_return_t rc
;
2156 char return_key
[MEMCACHED_MAX_KEY
];
2157 size_t return_key_length
;
2159 size_t return_value_length
;
2163 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2164 &return_value_length
, &flags
, &rc
)))
2166 test_true(return_value
);
2167 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2172 if (memcached_success(expect
) and memcached_success(rc
))
2174 return TEST_SUCCESS
;
2176 else if (expect
== rc
)
2178 return TEST_SUCCESS
;
2180 fprintf(stderr
, "\n%s:%u %s(#%u)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), keys_returned
);
2182 return TEST_FAILURE
;
2185 /* Test case provided by Cal Haldenbrand */
2186 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2187 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2188 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2190 /* We just keep looking at the same values over and over */
2193 unsigned int setter
= 1;
2194 test_compare(MEMCACHED_SUCCESS
,
2195 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2196 test_compare(MEMCACHED_SUCCESS
,
2197 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2201 unsigned long long total
= 0;
2202 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2204 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2205 char randomstuff
[6 * 1024];
2206 memset(randomstuff
, 0, 6 * 1024);
2207 test_true(size
< 6 * 1024); /* Being safe here */
2209 for (uint32_t j
= 0 ; j
< size
;j
++)
2211 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2216 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2217 test_compare(MEMCACHED_SUCCESS
,
2218 memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
));
2220 test_true(total
> HALDENBRAND_KEY_COUNT
);
2222 return TEST_SUCCESS
;
2225 /* Test case provided by Cal Haldenbrand */
2226 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2228 unsigned int setter
= 1;
2230 test_compare(MEMCACHED_SUCCESS
,
2231 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2233 test_compare(MEMCACHED_SUCCESS
,
2234 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2237 setter
= 20 * 1024576;
2238 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2239 setter
= 20 * 1024576;
2240 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2241 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2242 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2244 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2247 size_t total_value_length
= 0;
2248 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2253 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2254 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2256 memcached_return_t rc
;
2257 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2258 if (memcached_failed(rc
))
2260 if (rc
== MEMCACHED_NOTFOUND
)
2271 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2273 total_value_length
+= val_len
;
2278 return TEST_SUCCESS
;
2281 /* Do a large mget() over all the keys we think exist */
2282 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2284 unsigned int setter
= 1;
2285 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2286 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2288 setter
= 20 * 1024576;
2289 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2290 setter
= 20 * 1024576;
2291 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2292 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2293 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2296 size_t key_lengths
[HALDENBRAND_KEY_COUNT
];
2297 char **keys
= static_cast<char **>(calloc(HALDENBRAND_KEY_COUNT
, sizeof(char *)));
2299 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2301 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2302 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2303 keys
[x
]= strdup(key
);
2305 key_lengths
[x
]= key_length
;
2306 test_compare(size_t(key_length
), strlen(keys
[x
]));
2309 test_compare(MEMCACHED_SUCCESS
,
2310 memcached_mget(memc
, (const char **)keys
, key_lengths
, HALDENBRAND_KEY_COUNT
));
2312 unsigned int keys_returned
;
2313 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
2314 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2316 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2322 return TEST_SUCCESS
;
2325 /* Make sure we behave properly if server list has no values */
2326 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2328 const char *keys
[]= {"fudge", "son", "food"};
2329 size_t key_length
[]= {5, 3, 4};
2331 /* Here we free everything before running a bunch of mget tests */
2332 memcached_servers_reset(memc
);
2335 /* We need to empty the server before continueing test */
2336 test_compare(MEMCACHED_NO_SERVERS
,
2337 memcached_flush(memc
, 0));
2339 test_compare(MEMCACHED_NO_SERVERS
,
2340 memcached_mget(memc
, keys
, key_length
, 3));
2342 unsigned int keys_returned
;
2343 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2344 test_zero(keys_returned
);
2346 for (uint32_t x
= 0; x
< 3; x
++)
2348 test_compare(MEMCACHED_NO_SERVERS
,
2349 memcached_set(memc
, keys
[x
], key_length
[x
],
2350 keys
[x
], key_length
[x
],
2351 (time_t)50, (uint32_t)9));
2354 test_compare(MEMCACHED_NO_SERVERS
,
2355 memcached_mget(memc
, keys
, key_length
, 3));
2359 char return_key
[MEMCACHED_MAX_KEY
];
2360 memcached_return_t rc
;
2361 size_t return_key_length
;
2362 size_t return_value_length
;
2365 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2366 &return_value_length
, &flags
, &rc
)))
2368 test_true(return_value
);
2369 test_compare(MEMCACHED_SUCCESS
, rc
);
2370 test_true(return_key_length
== return_value_length
);
2371 test_memcmp(return_value
, return_key
, return_value_length
);
2377 return TEST_SUCCESS
;
2380 #define VALUE_SIZE_BUG5 1048064
2381 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2383 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2384 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2386 size_t value_length
;
2388 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2390 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2392 insert_data
[x
]= (signed char)rand();
2395 test_compare(MEMCACHED_SUCCESS
,
2396 memcached_flush(memc
, 0));
2398 memcached_return_t rc
;
2399 value
= memcached_get(memc
, keys
[0], key_length
[0],
2400 &value_length
, &flags
, &rc
);
2402 test_compare(MEMCACHED_SUCCESS
,
2403 memcached_mget(memc
, keys
, key_length
, 4));
2406 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2409 for (uint32_t x
= 0; x
< 4; x
++)
2411 test_compare(MEMCACHED_SUCCESS
,
2412 memcached_set(memc
, keys
[x
], key_length
[x
],
2413 insert_data
, VALUE_SIZE_BUG5
,
2414 (time_t)0, (uint32_t)0));
2417 for (uint32_t x
= 0; x
< 10; x
++)
2419 value
= memcached_get(memc
, keys
[0], key_length
[0],
2420 &value_length
, &flags
, &rc
);
2421 test_compare(rc
, MEMCACHED_SUCCESS
);
2425 test_compare(MEMCACHED_SUCCESS
,
2426 memcached_mget(memc
, keys
, key_length
, 4));
2428 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2429 test_compare(4U, count
);
2431 delete [] insert_data
;
2433 return TEST_SUCCESS
;
2436 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2438 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2439 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2440 char return_key
[MEMCACHED_MAX_KEY
];
2441 size_t return_key_length
;
2443 size_t value_length
;
2445 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2447 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2449 insert_data
[x
]= (signed char)rand();
2452 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2454 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2456 // We will now confirm that memcached_mget() returns success, but we will
2457 // then check to make sure that no actual keys are returned.
2458 test_compare(MEMCACHED_SUCCESS
,
2459 memcached_mget(memc
, keys
, key_length
, 4));
2461 memcached_return_t rc
;
2463 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2464 &value_length
, &flags
, &rc
)))
2469 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2471 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2473 test_compare(MEMCACHED_SUCCESS
,
2474 memcached_set(memc
, keys
[x
], key_length
[x
],
2475 insert_data
, VALUE_SIZE_BUG5
,
2476 (time_t)0, (uint32_t)0));
2478 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2480 for (uint32_t x
= 0; x
< 2; x
++)
2482 value
= memcached_get(memc
, keys
[0], key_length
[0],
2483 &value_length
, &flags
, &rc
);
2487 test_compare(MEMCACHED_SUCCESS
,
2488 memcached_mget(memc
, keys
, key_length
, 4));
2489 /* We test for purge of partial complete fetches */
2490 for (count
= 3; count
; count
--)
2492 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2493 &value_length
, &flags
, &rc
);
2494 test_compare(MEMCACHED_SUCCESS
, rc
);
2495 test_memcmp(value
, insert_data
, value_length
);
2496 test_true(value_length
);
2500 delete [] insert_data
;
2502 return TEST_SUCCESS
;
2505 static test_return_t
user_supplied_bug8(memcached_st
*)
2507 memcached_return_t rc
;
2509 memcached_st
*memc_clone
;
2511 memcached_server_st
*servers
;
2512 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";
2514 servers
= memcached_servers_parse(server_list
);
2517 mine
= memcached_create(NULL
);
2518 rc
= memcached_server_push(mine
, servers
);
2519 test_compare(MEMCACHED_SUCCESS
, rc
);
2520 memcached_server_list_free(servers
);
2523 memc_clone
= memcached_clone(NULL
, mine
);
2525 memcached_quit(mine
);
2526 memcached_quit(memc_clone
);
2529 memcached_free(mine
);
2530 memcached_free(memc_clone
);
2532 return TEST_SUCCESS
;
2535 /* Test flag store/retrieve */
2536 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2538 const char *keys
= "036790384900";
2539 size_t key_length
= strlen(keys
);
2540 char return_key
[MEMCACHED_MAX_KEY
];
2541 size_t return_key_length
;
2543 size_t value_length
;
2545 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2547 for (unsigned int x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2548 insert_data
[x
]= (signed char)rand();
2550 memcached_flush(memc
, 0);
2553 memcached_return_t rc
= memcached_set(memc
, keys
, key_length
,
2554 insert_data
, VALUE_SIZE_BUG5
,
2556 test_compare(MEMCACHED_SUCCESS
, rc
);
2559 value
= memcached_get(memc
, keys
, key_length
,
2560 &value_length
, &flags
, &rc
);
2561 test_true(flags
== 245);
2565 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2568 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2569 &value_length
, &flags
, &rc
);
2570 test_compare(uint32_t(245), flags
);
2573 delete [] insert_data
;
2576 return TEST_SUCCESS
;
2579 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2581 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2582 size_t key_length
[3];
2586 char return_key
[MEMCACHED_MAX_KEY
];
2587 size_t return_key_length
;
2589 size_t return_value_length
;
2592 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2593 key_length
[1]= strlen("fudge&*@#");
2594 key_length
[2]= strlen("for^#@&$not");
2597 for (unsigned int x
= 0; x
< 3; x
++)
2599 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2600 keys
[x
], key_length
[x
],
2601 (time_t)50, (uint32_t)9);
2602 test_compare(MEMCACHED_SUCCESS
, rc
);
2605 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2606 test_compare(MEMCACHED_SUCCESS
, rc
);
2608 /* We need to empty the server before continueing test */
2609 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2610 &return_value_length
, &flags
, &rc
)) != NULL
)
2612 test_true(return_value
);
2616 test_compare(3U, count
);
2618 return TEST_SUCCESS
;
2621 /* We are testing with aggressive timeout to get failures */
2622 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2624 size_t value_length
= 512;
2625 unsigned int set
= 1;
2626 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2628 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2629 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2630 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2632 char *value
= (char*)malloc(value_length
* sizeof(char));
2634 for (unsigned int x
= 0; x
< value_length
; x
++)
2636 value
[x
]= (char) (x
% 127);
2639 for (unsigned int x
= 1; x
<= 100000; ++x
)
2641 memcached_return_t rc
= memcached_set(mclone
,
2642 test_literal_param("foo"),
2643 value
, value_length
, 0, 0);
2645 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2646 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2647 memcached_strerror(NULL
, rc
));
2649 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2656 memcached_free(mclone
);
2658 return TEST_SUCCESS
;
2662 We are looking failures in the async protocol
2664 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2666 const char *key
= "foo";
2667 size_t value_length
= 512;
2669 unsigned int set
= 1;
2670 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2672 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2673 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2674 int32_t timeout
= -1;
2675 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, (size_t)timeout
);
2677 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2679 test_true(timeout
== -1);
2681 char *value
= (char*)malloc(value_length
* sizeof(char));
2683 for (unsigned int x
= 0; x
< value_length
; x
++)
2685 value
[x
]= (char) (x
% 127);
2688 for (unsigned int x
= 1; x
<= 100000; ++x
)
2690 memcached_return_t rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2695 memcached_free(mclone
);
2697 return TEST_SUCCESS
;
2701 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2703 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2705 memcached_return_t rc
;
2707 size_t value_length
;
2709 uint64_t number_value
;
2711 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2712 &value_length
, &flags
, &rc
);
2713 test_true(value
== NULL
);
2714 test_compare(MEMCACHED_NOTFOUND
, rc
);
2716 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2719 test_true(value
== NULL
);
2720 /* The binary protocol will set the key if it doesn't exist */
2721 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2723 test_compare(MEMCACHED_SUCCESS
, rc
);
2727 test_compare(MEMCACHED_NOTFOUND
, rc
);
2730 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2732 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2733 &value_length
, &flags
, &rc
);
2735 test_compare(MEMCACHED_SUCCESS
, rc
);
2738 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2740 test_true(number_value
== 2);
2741 test_compare(MEMCACHED_SUCCESS
, rc
);
2743 return TEST_SUCCESS
;
2747 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2748 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2750 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2752 char key
[] = "key34567890";
2753 memcached_return_t rc
;
2754 size_t overflowSize
;
2756 char commandFirst
[]= "set key34567890 0 0 ";
2757 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2758 size_t commandLength
;
2761 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2763 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2765 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2767 char *overflow
= new (std::nothrow
) char[testSize
];
2768 test_true(overflow
);
2770 memset(overflow
, 'x', testSize
);
2771 rc
= memcached_set(memc
, key
, strlen(key
),
2772 overflow
, testSize
, 0, 0);
2773 test_compare(MEMCACHED_SUCCESS
, rc
);
2777 return TEST_SUCCESS
;
2782 Test values of many different sizes
2783 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2784 set key34567890 0 0 8169 \r\n
2785 is sent followed by buffer of size 8169, followed by 8169
2787 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2789 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2791 std::vector
<char> value
;
2792 for (size_t x
= 0; x
< 18000; x
++)
2794 value
.push_back((char) (x
% 127));
2797 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2799 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2800 &value
[0], current_length
,
2801 (time_t)0, (uint32_t)0);
2802 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2804 size_t string_length
;
2806 char *string
= memcached_get(memc
, test_literal_param("foo"),
2807 &string_length
, &flags
, &rc
);
2809 test_compare(MEMCACHED_SUCCESS
, rc
);
2810 test_compare(string_length
, current_length
);
2811 test_memcmp(string
, &value
[0], string_length
);
2816 return TEST_SUCCESS
;
2820 Look for zero length value problems
2822 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2824 for (uint32_t x
= 0; x
< 2; x
++)
2826 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2828 (time_t)0, (uint32_t)0);
2830 test_compare(MEMCACHED_SUCCESS
, rc
);
2834 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2835 &length
, &flags
, &rc
);
2837 test_compare(MEMCACHED_SUCCESS
, rc
);
2842 value
= memcached_get(memc
, test_literal_param("mykey"),
2843 &length
, &flags
, &rc
);
2845 test_compare(MEMCACHED_SUCCESS
, rc
);
2846 test_true(value
== NULL
);
2851 return TEST_SUCCESS
;
2854 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2855 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2857 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2859 (time_t)0, UINT32_MAX
);
2861 test_compare(MEMCACHED_SUCCESS
, rc
);
2865 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2866 &length
, &flags
, &rc
);
2868 test_compare(MEMCACHED_SUCCESS
, rc
);
2869 test_true(value
== NULL
);
2871 test_compare(flags
, UINT32_MAX
);
2873 return TEST_SUCCESS
;
2876 #if !defined(__sun) && !defined(__OpenBSD__)
2877 /* Check the validity of chinese key*/
2878 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2880 const char *key
= "豆瓣";
2881 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2882 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2883 value
, strlen(value
),
2886 test_compare(MEMCACHED_SUCCESS
, rc
);
2890 char *value2
= memcached_get(memc
, key
, strlen(key
),
2891 &length
, &flags
, &rc
);
2893 test_true(length
==strlen(value
));
2894 test_compare(MEMCACHED_SUCCESS
, rc
);
2895 test_memcmp(value
, value2
, length
);
2898 return TEST_SUCCESS
;
2906 static test_return_t
user_supplied_bug19(memcached_st
*)
2908 memcached_return_t res
;
2910 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2912 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2915 memcached_free(memc
);
2917 return TEST_SUCCESS
;
2920 /* CAS test from Andei */
2921 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2923 const char *key
= "abc";
2924 size_t key_len
= strlen("abc");
2926 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2928 test_compare(MEMCACHED_SUCCESS
,
2930 test_literal_param("abc"),
2931 test_literal_param("foobar"),
2932 (time_t)0, (uint32_t)0));
2934 test_compare(MEMCACHED_SUCCESS
,
2935 memcached_mget(memc
, &key
, &key_len
, 1));
2937 memcached_result_st result_obj
;
2938 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2941 memcached_result_create(memc
, &result_obj
);
2942 memcached_return_t status
;
2943 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2946 test_compare(MEMCACHED_SUCCESS
, status
);
2948 memcached_result_free(result
);
2950 return TEST_SUCCESS
;
2953 /* Large mget() of missing keys with binary proto
2955 * If many binary quiet commands (such as getq's in an mget) fill the output
2956 * buffer and the server chooses not to respond, memcached_flush hangs. See
2957 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2960 /* sighandler_t function that always asserts false */
2961 static void fail(int)
2967 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2972 return TEST_SKIPPED
;
2974 void (*oldalarm
)(int);
2976 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2977 test_true(memc_clone
);
2979 /* only binproto uses getq for mget */
2980 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2982 /* empty the cache to ensure misses (hence non-responses) */
2983 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2985 size_t* key_lengths
= new (std::nothrow
) size_t[key_count
];
2986 test_true(key_lengths
);
2987 char **keys
= static_cast<char **>(calloc(key_count
, sizeof(char *)));
2989 for (unsigned int x
= 0; x
< key_count
; x
++)
2993 snprintf(buffer
, 30, "%u", x
);
2994 keys
[x
]= strdup(buffer
);
2996 key_lengths
[x
]= strlen(keys
[x
]);
2999 oldalarm
= signal(SIGALRM
, fail
);
3002 test_compare_got(MEMCACHED_SUCCESS
,
3003 memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
), memcached_last_error_message(memc_clone
));
3006 signal(SIGALRM
, oldalarm
);
3008 memcached_return_t rc
;
3010 char return_key
[MEMCACHED_MAX_KEY
];
3011 size_t return_key_length
;
3013 size_t return_value_length
;
3014 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
3015 &return_value_length
, &flags
, &rc
)))
3017 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
3019 test_compare(MEMCACHED_NOTFOUND
, rc
);
3020 test_zero(return_value_length
);
3021 test_zero(return_key_length
);
3022 test_false(return_key
[0]);
3023 test_false(return_value
);
3025 for (unsigned int x
= 0; x
< key_count
; x
++)
3030 delete [] key_lengths
;
3032 memcached_free(memc_clone
);
3034 return TEST_SUCCESS
;
3038 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3040 test_return_t test_rc
;
3041 test_rc
= pre_binary(memc
);
3043 if (test_rc
!= TEST_SUCCESS
)
3048 /* should work as of r580 */
3049 test_compare(TEST_SUCCESS
,
3050 _user_supplied_bug21(memc
, 10));
3052 /* should fail as of r580 */
3053 test_compare(TEST_SUCCESS
,
3054 _user_supplied_bug21(memc
, 1000));
3056 return TEST_SUCCESS
;
3059 static test_return_t
output_ketama_weighted_keys(memcached_st
*)
3061 memcached_st
*memc
= memcached_create(NULL
);
3065 test_compare(MEMCACHED_SUCCESS
,
3066 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
3068 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3069 test_compare(value
, uint64_t(1));
3071 test_compare(MEMCACHED_SUCCESS
,
3072 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3074 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3075 test_true(value
== MEMCACHED_HASH_MD5
);
3078 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3080 memcached_server_st
*server_pool
;
3081 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");
3082 memcached_server_push(memc
, server_pool
);
3084 // @todo this needs to be refactored to actually test something.
3087 if ((fp
= fopen("ketama_keys.txt", "w")))
3091 printf("cannot write to file ketama_keys.txt");
3092 return TEST_FAILURE
;
3095 for (int x
= 0; x
< 10000; x
++)
3098 snprintf(key
, sizeof(key
), "%d", x
);
3100 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3101 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3102 in_port_t port
= memc
->hosts
[server_idx
].port
;
3103 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3104 memcached_server_instance_st instance
=
3105 memcached_server_instance_by_position(memc
, host_index
);
3109 memcached_server_list_free(server_pool
);
3110 memcached_free(memc
);
3112 return TEST_SUCCESS
;
3116 static test_return_t
result_static(memcached_st
*memc
)
3118 memcached_result_st result
;
3119 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3120 test_false(result
.options
.is_allocated
);
3121 test_true(memcached_is_initialized(&result
));
3122 test_true(result_ptr
);
3123 test_true(result_ptr
== &result
);
3125 memcached_result_free(&result
);
3127 test_false(result
.options
.is_allocated
);
3128 test_false(memcached_is_initialized(&result
));
3130 return TEST_SUCCESS
;
3133 static test_return_t
result_alloc(memcached_st
*memc
)
3135 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3136 test_true(result_ptr
);
3137 test_true(result_ptr
->options
.is_allocated
);
3138 test_true(memcached_is_initialized(result_ptr
));
3139 memcached_result_free(result_ptr
);
3141 return TEST_SUCCESS
;
3144 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3147 pairs_free(global_pairs
);
3149 return TEST_SUCCESS
;
3152 static test_return_t
generate_pairs(memcached_st
*)
3154 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3155 global_count
= GLOBAL_COUNT
;
3157 for (size_t x
= 0; x
< global_count
; x
++)
3159 global_keys
[x
]= global_pairs
[x
].key
;
3160 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3163 return TEST_SUCCESS
;
3166 static test_return_t
generate_large_pairs(memcached_st
*)
3168 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3169 global_count
= GLOBAL2_COUNT
;
3171 for (size_t x
= 0; x
< global_count
; x
++)
3173 global_keys
[x
]= global_pairs
[x
].key
;
3174 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3177 return TEST_SUCCESS
;
3180 static test_return_t
generate_data(memcached_st
*memc
)
3182 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3184 test_compare(check_execute
, global_count
);
3186 return TEST_SUCCESS
;
3189 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3191 uint32_t host_index
= 0;
3192 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3194 test_true(check_execute
== global_count
);
3196 // @todo hosts used size stats
3197 memcached_return_t rc
;
3198 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3201 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3203 /* This test was changes so that "make test" would work properlly */
3206 memcached_server_instance_st instance
=
3207 memcached_server_instance_by_position(memc
, host_index
);
3209 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3211 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3214 memcached_stat_free(NULL
, stat_p
);
3216 return TEST_SUCCESS
;
3218 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3220 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3221 generate_data(memc
);
3223 return TEST_SUCCESS
;
3226 static test_return_t
get_read_count(memcached_st
*memc
)
3228 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3229 test_true(memc_clone
);
3231 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3235 size_t return_value_length
;
3239 for (size_t x
= count
= 0; x
< global_count
; x
++)
3241 memcached_return_t rc
;
3242 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3243 &return_value_length
, &flags
, &rc
);
3244 if (rc
== MEMCACHED_SUCCESS
)
3255 memcached_free(memc_clone
);
3257 return TEST_SUCCESS
;
3260 static test_return_t
get_read(memcached_st
*memc
)
3262 for (size_t x
= 0; x
< global_count
; x
++)
3264 size_t return_value_length
;
3266 memcached_return_t rc
;
3267 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3268 &return_value_length
, &flags
, &rc
);
3270 test_true(return_value);
3271 test_compare(MEMCACHED_SUCCESS, rc);
3273 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3279 return TEST_SUCCESS
;
3282 static test_return_t
mget_read(memcached_st
*memc
)
3285 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3287 test_compare(MEMCACHED_SUCCESS
,
3288 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3290 // Go fetch the keys and test to see if all of them were returned
3292 unsigned int keys_returned
;
3293 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3294 test_true(keys_returned
> 0);
3295 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3298 return TEST_SUCCESS
;
3301 static test_return_t
mget_read_result(memcached_st
*memc
)
3304 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3306 test_compare(MEMCACHED_SUCCESS
,
3307 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3309 /* Turn this into a help function */
3311 memcached_result_st results_obj
;
3312 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3315 memcached_return_t rc
;
3316 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3318 if (rc
== MEMCACHED_IN_PROGRESS
)
3324 test_compare(MEMCACHED_SUCCESS
, rc
);
3326 test_compare(MEMCACHED_END
, rc
);
3328 memcached_result_free(&results_obj
);
3331 return TEST_SUCCESS
;
3334 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3337 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3339 test_compare(MEMCACHED_SUCCESS
,
3340 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3342 memcached_result_st
*results
= NULL
;
3343 memcached_return_t rc
;
3344 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3347 test_compare(MEMCACHED_SUCCESS
, rc
);
3349 test_compare(MEMCACHED_END
, rc
);
3351 memcached_result_free(results
);
3354 return TEST_SUCCESS
;
3357 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3360 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3362 test_compare(MEMCACHED_SUCCESS
,
3363 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3365 // We will scan for just one key
3367 memcached_result_st results_obj
;
3368 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3370 memcached_return_t rc
;
3371 results
= memcached_fetch_result(memc
, results
, &rc
);
3373 test_compare(MEMCACHED_SUCCESS
, rc
);
3375 memcached_result_free(&results_obj
);
3378 // We already have a read happening, lets start up another one.
3379 test_compare(MEMCACHED_SUCCESS
,
3380 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3382 memcached_result_st results_obj
;
3383 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3385 test_false(memcached_is_allocated(results
));
3387 memcached_return_t rc
;
3388 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3391 test_compare(MEMCACHED_SUCCESS
, rc
);
3393 test_compare(MEMCACHED_END
, rc
);
3395 memcached_result_free(&results_obj
);
3398 return TEST_SUCCESS
;
3401 static test_return_t
mget_read_function(memcached_st
*memc
)
3403 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3405 test_compare(MEMCACHED_SUCCESS
,
3406 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3408 memcached_execute_fn callbacks
[]= { &callback_counter
};
3410 test_compare(MEMCACHED_SUCCESS
,
3411 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3413 return TEST_SUCCESS
;
3416 static test_return_t
delete_generate(memcached_st
*memc
)
3418 for (size_t x
= 0; x
< global_count
; x
++)
3420 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3423 return TEST_SUCCESS
;
3426 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3428 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3430 for (size_t x
= 0; x
< global_count
; x
++)
3432 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3435 return TEST_SUCCESS
;
3438 static test_return_t
add_host_test1(memcached_st
*memc
)
3440 memcached_return_t rc
;
3441 char servername
[]= "0.example.com";
3443 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3445 test_compare(1U, memcached_server_list_count(servers
));
3447 for (uint32_t x
= 2; x
< 20; x
++)
3449 char buffer
[SMALL_STRING_LEN
];
3451 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3452 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3454 test_compare(MEMCACHED_SUCCESS
, rc
);
3455 test_compare(x
, memcached_server_list_count(servers
));
3458 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3459 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3461 memcached_server_list_free(servers
);
3463 return TEST_SUCCESS
;
3466 static test_return_t
pre_nonblock(memcached_st
*memc
)
3468 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3470 return TEST_SUCCESS
;
3473 static test_return_t
pre_cork(memcached_st
*memc
)
3476 return TEST_SKIPPED
;
3479 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3480 return TEST_SUCCESS
;
3482 return TEST_SKIPPED
;
3485 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3488 return TEST_SKIPPED
;
3490 test_return_t test_rc
;
3491 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3494 return pre_nonblock(memc
);
3497 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3499 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3500 test_true(memc_clone
);
3502 // The memcached_version needs to be done on a clone, because the server
3503 // will not toggle protocol on an connection.
3504 memcached_version(memc_clone
);
3506 memcached_return_t rc
= MEMCACHED_FAILURE
;
3507 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3509 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3510 test_compare(MEMCACHED_SUCCESS
,
3511 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3512 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3516 memcached_free(memc_clone
);
3517 return TEST_SKIPPED
;
3520 memcached_free(memc_clone
);
3522 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3525 static test_return_t
pre_murmur(memcached_st
*memc
)
3527 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3528 return TEST_SUCCESS
;
3531 static test_return_t
pre_jenkins(memcached_st
*memc
)
3533 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3535 return TEST_SUCCESS
;
3539 static test_return_t
pre_md5(memcached_st
*memc
)
3541 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3543 return TEST_SUCCESS
;
3546 static test_return_t
pre_crc(memcached_st
*memc
)
3548 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3550 return TEST_SUCCESS
;
3553 static test_return_t
pre_hsieh(memcached_st
*memc
)
3555 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
));
3556 return TEST_SUCCESS
;
3559 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3561 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3563 return TEST_SUCCESS
;
3566 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3568 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
));
3570 return TEST_SUCCESS
;
3573 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3575 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3577 return TEST_SUCCESS
;
3580 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3582 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3584 return TEST_SUCCESS
;
3587 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3589 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3590 test_compare(MEMCACHED_SUCCESS
, rc
);
3592 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3593 test_compare(value
, uint64_t(1));
3595 return TEST_SUCCESS
;
3598 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3600 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3601 test_compare(MEMCACHED_SUCCESS
, rc
);
3603 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3604 test_compare(value
, uint64_t(1));
3606 test_compare(MEMCACHED_SUCCESS
,
3607 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3609 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3610 test_compare(MEMCACHED_HASH_MD5
, memcached_hash_t(value
));
3612 return TEST_SUCCESS
;
3616 @note This should be testing to see if the server really supports the binary protocol.
3618 static test_return_t
pre_binary(memcached_st
*memc
)
3620 memcached_return_t rc
= MEMCACHED_FAILURE
;
3622 if (libmemcached_util_version_check(memc
, 1, 4, 4))
3624 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3625 test_compare(MEMCACHED_SUCCESS
, rc
);
3626 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3629 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3632 static test_return_t
pre_replication(memcached_st
*memc
)
3634 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3637 * Make sure that we store the item on all servers
3638 * (master + replicas == number of servers)
3640 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3641 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3643 return TEST_SUCCESS
;
3647 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3649 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3651 return pre_nonblock(memc
);
3655 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3659 #ifdef HARD_MALLOC_TESTS
3660 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3668 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3672 #ifdef HARD_MALLOC_TESTS
3673 void *ret
= malloc(size
+ 8);
3676 ret
= (void*)((caddr_t
)ret
+ 8);
3679 void *ret
= malloc(size
);
3684 memset(ret
, 0xff, size
);
3691 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3693 #ifdef HARD_MALLOC_TESTS
3694 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3695 void *nmem
= realloc(real_ptr
, size
+ 8);
3700 ret
= (void*)((caddr_t
)nmem
+ 8);
3706 return realloc(mem
, size
);
3711 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3713 #ifdef HARD_MALLOC_TESTS
3714 void *mem
= my_malloc(ptr
, nelem
* size
);
3717 memset(mem
, 0, nelem
* size
);
3723 return calloc(nelem
, size
);
3727 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3729 memcached_return_t rc
;
3730 const char *key
= "mine";
3733 /* Make sure be default none exists */
3734 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
);
3808 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3810 /* Test a clean set */
3811 test_compare(MEMCACHED_SUCCESS
,
3812 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3814 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3816 test_memcmp(value
, key
, 4);
3817 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3819 return TEST_SUCCESS
;
3822 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3824 test_return_if(pre_binary(memc
));
3825 test_return_if(set_namespace(memc
));
3827 return TEST_SUCCESS
;
3830 #ifdef MEMCACHED_ENABLE_DEPRECATED
3831 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3833 void *test_ptr
= NULL
;
3836 memcached_malloc_fn malloc_cb
=
3837 (memcached_malloc_fn
)my_malloc
;
3838 cb_ptr
= *(void **)&malloc_cb
;
3839 memcached_return_t rc
;
3841 test_compare(MEMCACHED_SUCCESS
,
3842 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3843 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3844 test_compare(MEMCACHED_SUCCESS
, rc
);
3845 test_true(test_ptr
== cb_ptr
);
3849 memcached_realloc_fn realloc_cb
=
3850 (memcached_realloc_fn
)my_realloc
;
3851 cb_ptr
= *(void **)&realloc_cb
;
3852 memcached_return_t rc
;
3854 test_compare(MEMCACHED_SUCCESS
,
3855 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3856 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3857 test_compare(MEMCACHED_SUCCESS
, rc
);
3858 test_true(test_ptr
== cb_ptr
);
3862 memcached_free_fn free_cb
=
3863 (memcached_free_fn
)my_free
;
3864 cb_ptr
= *(void **)&free_cb
;
3865 memcached_return_t rc
;
3867 test_compare(MEMCACHED_SUCCESS
,
3868 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3869 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3870 test_compare(MEMCACHED_SUCCESS
, rc
);
3871 test_true(test_ptr
== cb_ptr
);
3874 return TEST_SUCCESS
;
3879 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3881 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3882 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3883 my_realloc
, my_calloc
, NULL
));
3885 test_compare(MEMCACHED_SUCCESS
,
3886 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3887 my_realloc
, my_calloc
, NULL
));
3889 memcached_malloc_fn mem_malloc
;
3890 memcached_free_fn mem_free
;
3891 memcached_realloc_fn mem_realloc
;
3892 memcached_calloc_fn mem_calloc
;
3893 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3894 &mem_realloc
, &mem_calloc
);
3896 test_true(mem_malloc
== my_malloc
);
3897 test_true(mem_realloc
== my_realloc
);
3898 test_true(mem_calloc
== my_calloc
);
3899 test_true(mem_free
== my_free
);
3901 return TEST_SUCCESS
;
3904 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3907 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3908 memcached_hash_t hash
;
3909 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3910 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3913 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3914 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3916 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3918 if (hash
!= MEMCACHED_HASH_CRC
)
3919 return TEST_SKIPPED
;
3921 return TEST_SUCCESS
;
3924 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3927 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3928 memcached_hash_t hash
;
3929 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3930 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3935 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3936 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3938 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3940 if (hash
!= MEMCACHED_HASH_HSIEH
)
3941 return TEST_SKIPPED
;
3944 return TEST_SUCCESS
;
3947 static test_return_t
enable_cas(memcached_st
*memc
)
3949 unsigned int set
= 1;
3951 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3953 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3955 return TEST_SUCCESS
;
3958 return TEST_SKIPPED
;
3961 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3963 memcached_version(memc
);
3965 memcached_server_instance_st instance
=
3966 memcached_server_instance_by_position(memc
, 0);
3968 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3969 or instance
->minor_version
> 2)
3971 return TEST_SUCCESS
;
3974 return TEST_SKIPPED
;
3977 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3981 memcached_servers_reset(memc
);
3982 const char *socket_file
= default_socket();
3984 test_skip(0, stat(socket_file
, &buf
));
3986 test_compare(MEMCACHED_SUCCESS
,
3987 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
3989 return TEST_SUCCESS
;
3992 static test_return_t
pre_nodelay(memcached_st
*memc
)
3994 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3995 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3997 return TEST_SUCCESS
;
4000 static test_return_t
pre_settimer(memcached_st
*memc
)
4002 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4003 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4005 return TEST_SUCCESS
;
4008 static test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
4010 const uint64_t timeout
= 100; // Not using, just checking that it sets
4012 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4014 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
4016 return TEST_SUCCESS
;
4019 static test_return_t
noreply_test(memcached_st
*memc
)
4021 test_compare(MEMCACHED_SUCCESS
,
4022 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4023 test_compare(MEMCACHED_SUCCESS
,
4024 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1));
4025 test_compare(MEMCACHED_SUCCESS
,
4026 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4027 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
4028 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
4029 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
4031 memcached_return_t ret
;
4032 for (int count
= 0; count
< 5; ++count
)
4034 for (size_t x
= 0; x
< 100; ++x
)
4037 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4038 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4040 size_t len
= (size_t)check_length
;
4045 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4048 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4051 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4054 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4057 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4063 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, ret
));
4067 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4068 ** API and is _ONLY_ done this way to verify that the library works the
4069 ** way it is supposed to do!!!!
4072 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4074 memcached_server_instance_st instance
=
4075 memcached_server_instance_by_position(memc
, x
);
4076 no_msg
+=(int)(instance
->cursor_active
);
4079 test_true(no_msg
== 0);
4080 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4083 ** Now validate that all items was set properly!
4085 for (size_t x
= 0; x
< 100; ++x
)
4089 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4091 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4093 size_t len
= (size_t)check_length
;
4096 char* value
=memcached_get(memc
, key
, strlen(key
),
4097 &length
, &flags
, &ret
);
4098 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
4101 case 0: /* FALLTHROUGH */
4102 case 1: /* FALLTHROUGH */
4104 test_true(strncmp(value
, key
, len
) == 0);
4105 test_true(len
== length
);
4108 test_true(length
== len
* 2);
4111 test_true(length
== len
* 3);
4121 /* Try setting an illegal cas value (should not return an error to
4122 * the caller (because we don't expect a return message from the server)
4124 const char* keys
[]= {"0"};
4125 size_t lengths
[]= {1};
4128 memcached_result_st results_obj
;
4129 memcached_result_st
*results
;
4130 test_compare(MEMCACHED_SUCCESS
,
4131 memcached_mget(memc
, keys
, lengths
, 1));
4133 results
= memcached_result_create(memc
, &results_obj
);
4135 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4137 test_compare(MEMCACHED_SUCCESS
, ret
);
4138 uint64_t cas
= memcached_result_cas(results
);
4139 memcached_result_free(&results_obj
);
4141 test_compare(MEMCACHED_SUCCESS
,
4142 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4145 * The item will have a new cas value, so try to set it again with the old
4146 * value. This should fail!
4148 test_compare(MEMCACHED_SUCCESS
,
4149 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4150 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4151 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4152 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4155 return TEST_SUCCESS
;
4158 static test_return_t
analyzer_test(memcached_st
*memc
)
4160 memcached_return_t rc
;
4161 memcached_analysis_st
*report
;
4163 memcached_stat_st
*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 volatile memcached_return_t rc
;
4197 memcached_pool_st
* pool
;
4201 test_pool_context_st(memcached_pool_st
*pool_arg
, memcached_st
*memc_arg
):
4202 rc(MEMCACHED_FAILURE
),
4206 sem_init(&lock
, 0, 0);
4209 ~test_pool_context_st()
4215 static void* connection_release(void *arg
)
4217 test_pool_context_st
*resource
= static_cast<test_pool_context_st
*>(arg
);
4219 if (resource
== NULL
)
4224 sem_wait(&resource
->lock
);
4225 // Release all of the memc we are holding
4226 resource
->rc
= memcached_pool_push(resource
->pool
, resource
->mmc
);
4231 #define POOL_SIZE 10
4232 static test_return_t
connection_pool_test(memcached_st
*memc
)
4234 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4236 memcached_st
*mmc
[POOL_SIZE
];
4237 memcached_return_t rc
;
4239 // Fill up our array that we will store the memc that are in the pool
4240 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4242 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4244 test_compare(MEMCACHED_SUCCESS
, rc
);
4247 // All memc should be gone
4248 test_null(memcached_pool_pop(pool
, false, &rc
));
4249 test_compare(MEMCACHED_SUCCESS
, rc
);
4252 @note This comment was written to describe what was believed to be the original authors intent.
4254 This portion of the test creates a thread that will wait until told to free a memcached_st
4255 that will be grabbed by the main thread.
4257 It is believed that this tests whether or not we are handling ownership correctly.
4261 test_pool_context_st
item(pool
, mmc
[9]);
4263 test_zero(pthread_create(&tid
, NULL
, connection_release
, &item
));
4264 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4265 if (rc
!= MEMCACHED_SUCCESS
)
4267 sem_post(&item
.lock
);
4268 pthread_join(tid
, NULL
);
4270 else if (rc
== MEMCACHED_TIMEOUT
)
4272 Error
<< "Possible timing issue with memcached_pool_pop";
4276 test_compare(MEMCACHED_SUCCESS
, rc
);
4279 sem_post(&item
.lock
);
4280 pthread_join(tid
, NULL
);
4281 if (rc
== MEMCACHED_SUCCESS
)
4283 test_compare(MEMCACHED_SUCCESS
, item
.rc
);
4289 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4293 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[x
]));
4296 test_true(memcached_pool_destroy(pool
) == memc
);
4298 return TEST_SUCCESS
;
4301 static test_return_t
connection_pool2_test(memcached_st
*memc
)
4303 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4305 memcached_st
*mmc
[POOL_SIZE
];
4306 memcached_return_t rc
;
4308 // Fill up our array that we will store the memc that are in the pool
4309 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4311 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4313 test_compare(MEMCACHED_SUCCESS
, rc
);
4316 // All memc should be gone
4317 test_null(memcached_pool_pop(pool
, false, &rc
));
4318 test_compare(MEMCACHED_SUCCESS
, rc
);
4320 // verify that I can do ops with all connections
4321 test_compare(MEMCACHED_SUCCESS
,
4322 memcached_set(mmc
[0],
4323 test_literal_param("key"),
4326 for (uint64_t x
= 0; x
< POOL_SIZE
; ++x
)
4328 uint64_t number_value
;
4329 test_compare(MEMCACHED_SUCCESS
,
4330 memcached_increment(mmc
[x
],
4331 test_literal_param("key"),
4333 test_compare(number_value
, (x
+1));
4337 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4339 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[x
]));
4343 /* verify that I can set behaviors on the pool when I don't have all
4344 * of the connections in the pool. It should however be enabled
4345 * when I push the item into the pool
4347 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4350 test_compare(MEMCACHED_SUCCESS
,
4351 memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999));
4353 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4356 test_compare(UINT64_C(9999), memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4357 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[1]));
4358 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4360 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4361 test_compare(UINT64_C(9999), memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4362 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4364 test_true(memcached_pool_destroy(pool
) == memc
);
4366 return TEST_SUCCESS
;
4369 static test_return_t
util_version_test(memcached_st
*memc
)
4371 bool if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4372 test_true(if_successful
);
4374 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4376 // We expect failure
4379 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4380 fprintf(stderr
, "\nDumping Server Information\n\n");
4381 memcached_server_fn callbacks
[1];
4383 callbacks
[0]= dump_server_information
;
4384 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4385 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4387 test_true(if_successful
== false);
4389 memcached_server_instance_st instance
=
4390 memcached_server_instance_by_position(memc
, 0);
4392 memcached_version(memc
);
4394 // We only use one binary when we test, so this should be just fine.
4395 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4396 test_true(if_successful
== true);
4398 if (instance
->micro_version
> 0)
4400 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4402 else if (instance
->minor_version
> 0)
4404 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4406 else if (instance
->major_version
> 0)
4408 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4411 test_true(if_successful
== true);
4413 if (instance
->micro_version
> 0)
4415 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4417 else if (instance
->minor_version
> 0)
4419 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4421 else if (instance
->major_version
> 0)
4423 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4426 test_true(if_successful
== false);
4428 return TEST_SUCCESS
;
4431 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4433 memcached_return_t rc
;
4434 memcached_server_instance_st instance
=
4435 memcached_server_instance_by_position(memc
, 0);
4437 // Test both the version that returns a code, and the one that does not.
4438 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4439 memcached_server_port(instance
) -1, NULL
) == -1);
4441 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4442 memcached_server_port(instance
) -1, &rc
) == -1);
4443 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4445 return TEST_SUCCESS
;
4449 static test_return_t
getpid_test(memcached_st
*memc
)
4451 memcached_return_t rc
;
4452 memcached_server_instance_st instance
=
4453 memcached_server_instance_by_position(memc
, 0);
4455 // Test both the version that returns a code, and the one that does not.
4456 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4457 memcached_server_port(instance
), NULL
) > -1);
4459 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4460 memcached_server_port(instance
), &rc
) > -1);
4461 test_compare(MEMCACHED_SUCCESS
, rc
);
4463 return TEST_SUCCESS
;
4466 static test_return_t
ping_test(memcached_st
*memc
)
4468 memcached_return_t rc
;
4469 memcached_server_instance_st instance
=
4470 memcached_server_instance_by_position(memc
, 0);
4472 // Test both the version that returns a code, and the one that does not.
4473 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4474 memcached_server_port(instance
), NULL
));
4476 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4477 memcached_server_port(instance
), &rc
));
4479 test_compare(MEMCACHED_SUCCESS
, rc
);
4481 return TEST_SUCCESS
;
4486 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4490 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4491 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4492 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4493 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4494 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4495 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4496 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4497 #ifdef HAVE_HSIEH_HASH
4498 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4500 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4501 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4502 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4504 return TEST_SUCCESS
;
4508 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4510 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4512 test_compare(MEMCACHED_SUCCESS
,
4513 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4514 (uint64_t)MEMCACHED_HASH_HSIEH
));
4516 return TEST_SUCCESS
;
4519 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4521 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4523 test_compare(MEMCACHED_SUCCESS
,
4524 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
4526 return TEST_SUCCESS
;
4529 static test_return_t
one_at_a_time_run (memcached_st
*)
4534 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4536 test_compare(one_at_a_time_values
[x
],
4537 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
4540 return TEST_SUCCESS
;
4543 static test_return_t
md5_run (memcached_st
*)
4548 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4550 test_compare(md5_values
[x
],
4551 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
4554 return TEST_SUCCESS
;
4557 static test_return_t
crc_run (memcached_st
*)
4562 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4564 test_compare(crc_values
[x
],
4565 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
4568 return TEST_SUCCESS
;
4571 static test_return_t
fnv1_64_run (memcached_st
*)
4573 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
4578 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4580 test_compare(fnv1_64_values
[x
],
4581 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
4584 return TEST_SUCCESS
;
4587 static test_return_t
fnv1a_64_run (memcached_st
*)
4589 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
4594 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4596 test_compare(fnv1a_64_values
[x
],
4597 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
4600 return TEST_SUCCESS
;
4603 static test_return_t
fnv1_32_run (memcached_st
*)
4608 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4610 test_compare(fnv1_32_values
[x
],
4611 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
4614 return TEST_SUCCESS
;
4617 static test_return_t
fnv1a_32_run (memcached_st
*)
4622 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4624 test_compare(fnv1a_32_values
[x
],
4625 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
4628 return TEST_SUCCESS
;
4631 static test_return_t
hsieh_run (memcached_st
*)
4633 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4638 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4640 test_compare(hsieh_values
[x
],
4641 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
4644 return TEST_SUCCESS
;
4647 static test_return_t
murmur_run (memcached_st
*)
4649 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4651 #ifdef WORDS_BIGENDIAN
4652 (void)murmur_values
;
4653 return TEST_SKIPPED
;
4658 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4660 test_compare(murmur_values
[x
],
4661 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
4664 return TEST_SUCCESS
;
4668 static test_return_t
jenkins_run (memcached_st
*)
4673 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4675 test_compare(jenkins_values
[x
],
4676 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
4679 return TEST_SUCCESS
;
4682 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
4684 return libhashkit_md5(string
, string_length
);
4687 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
4689 return libhashkit_crc32(string
, string_length
);
4692 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4698 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5"));
4700 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};
4701 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};
4703 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4705 hashkit_clone(&new_kit
, kit
);
4706 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4708 memcached_set_hashkit(memc
, &new_kit
);
4711 Verify Setting the hash.
4713 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4717 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4718 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4723 Now check memcached_st.
4725 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4729 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4730 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4733 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4735 memcached_set_hashkit(memc
, &new_kit
);
4738 Verify Setting the hash.
4740 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4744 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4745 test_true(crc_values
[x
] == hash_val
);
4748 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4752 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4753 test_compare(crc_hosts
[x
], hash_val
);
4756 memcached_free(memc
);
4758 return TEST_SUCCESS
;
4762 Test case adapted from John Gorman <johngorman2@gmail.com>
4764 We are testing the error condition when we connect to a server via memcached_get()
4765 but find that the server is not available.
4767 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4769 const char *key
= "MemcachedLives";
4772 memcached_return rc
;
4775 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4777 // See if memcached is reachable.
4778 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4782 test_true(memcached_failed(rc
));
4784 memcached_free(tl_memc_h
);
4786 return TEST_SUCCESS
;
4790 We connect to a server which exists, but search for a key that does not exist.
4792 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4794 const char *key
= "MemcachedKeyNotEXIST";
4797 memcached_return rc
;
4799 // See if memcached is reachable.
4800 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4804 test_compare(MEMCACHED_NOTFOUND
, rc
);
4806 return TEST_SUCCESS
;
4810 Test case adapted from John Gorman <johngorman2@gmail.com>
4812 We are testing the error condition when we connect to a server via memcached_get_by_key()
4813 but find that the server is not available.
4815 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4818 memcached_st
*tl_memc_h
;
4819 memcached_server_st
*servers
;
4821 const char *key
= "MemcachedLives";
4824 memcached_return rc
;
4828 tl_memc_h
= memcached_create(NULL
);
4829 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4830 memcached_server_push(tl_memc_h
, servers
);
4831 memcached_server_list_free(servers
);
4833 // See if memcached is reachable.
4834 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4838 test_true(memcached_failed(rc
));
4840 memcached_free(tl_memc_h
);
4842 return TEST_SUCCESS
;
4846 We connect to a server which exists, but search for a key that does not exist.
4848 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4850 const char *key
= "MemcachedKeyNotEXIST";
4853 memcached_return rc
;
4856 // See if memcached is reachable.
4857 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4861 test_compare(MEMCACHED_NOTFOUND
, rc
);
4863 return TEST_SUCCESS
;
4866 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4868 test_return_t test_rc
;
4869 test_rc
= pre_binary(memc
);
4871 if (test_rc
!= TEST_SUCCESS
)
4874 const char *key
= "regression_bug_434484";
4875 size_t keylen
= strlen(key
);
4877 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4878 test_compare(MEMCACHED_NOTSTORED
, ret
);
4880 size_t size
= 2048 * 1024;
4881 char *data
= (char*)calloc(1, size
);
4883 test_compare(MEMCACHED_E2BIG
,
4884 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4887 return TEST_SUCCESS
;
4890 static test_return_t
regression_bug_434843(memcached_st
*memc
)
4892 test_return_t test_rc
;
4893 test_rc
= pre_binary(memc
);
4895 if (test_rc
!= TEST_SUCCESS
)
4898 memcached_return_t rc
;
4900 memcached_execute_fn callbacks
[]= { &callback_counter
};
4903 * I only want to hit only _one_ server so I know the number of requests I'm
4904 * sending in the pipleine to the server. Let's try to do a multiget of
4905 * 1024 (that should satisfy most users don't you think?). Future versions
4906 * will include a mget_execute function call if you need a higher number.
4908 uint32_t number_of_hosts
= memcached_server_count(memc
);
4909 memc
->number_of_hosts
= 1;
4910 const size_t max_keys
= 1024;
4911 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4912 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4914 for (size_t x
= 0; x
< max_keys
; ++x
)
4918 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4924 * Run two times.. the first time we should have 100% cache miss,
4925 * and the second time we should have 100% cache hits
4927 for (size_t y
= 0; y
< 2; y
++)
4929 test_compare(MEMCACHED_SUCCESS
,
4930 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4932 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4933 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4937 /* The first iteration should give me a 100% cache miss. verify that*/
4938 char blob
[1024]= { 0 };
4940 test_false(counter
);
4942 for (size_t x
= 0; x
< max_keys
; ++x
)
4944 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4945 blob
, sizeof(blob
), 0, 0);
4946 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4951 /* Verify that we received all of the key/value pairs */
4952 test_compare(counter
, max_keys
);
4956 /* Release allocated resources */
4957 for (size_t x
= 0; x
< max_keys
; ++x
)
4964 memc
->number_of_hosts
= number_of_hosts
;
4966 return TEST_SUCCESS
;
4969 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4971 memcached_return_t rc
;
4972 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4973 test_compare(MEMCACHED_SUCCESS
, rc
);
4975 return regression_bug_434843(memc
);
4978 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4980 memcached_return_t rc
;
4981 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4982 test_compare(MEMCACHED_SUCCESS
, rc
);
4984 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4985 test_compare(MEMCACHED_SUCCESS
, rc
);
4986 test_true(bytes_str
);
4987 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4989 test_compare(MEMCACHED_SUCCESS
, rc
);
4990 test_true(bytes_read_str
);
4992 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4993 "bytes_written", &rc
);
4994 test_compare(MEMCACHED_SUCCESS
, rc
);
4995 test_true(bytes_written_str
);
4997 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4998 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4999 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
5001 test_true(bytes
!= bytes_read
);
5002 test_true(bytes
!= bytes_written
);
5004 /* Release allocated resources */
5006 free(bytes_read_str
);
5007 free(bytes_written_str
);
5008 memcached_stat_free(NULL
, memc_stat
);
5010 return TEST_SUCCESS
;
5014 * The test case isn't obvious so I should probably document why
5015 * it works the way it does. Bug 442914 was caused by a bug
5016 * in the logic in memcached_purge (it did not handle the case
5017 * where the number of bytes sent was equal to the watermark).
5018 * In this test case, create messages so that we hit that case
5019 * and then disable noreply mode and issue a new command to
5020 * verify that it isn't stuck. If we change the format for the
5021 * delete command or the watermarks, we need to update this
5024 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5026 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5027 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5029 uint32_t number_of_hosts
= memcached_server_count(memc
);
5030 memc
->number_of_hosts
= 1;
5035 for (uint32_t x
= 0; x
< 250; ++x
)
5037 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5038 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
5039 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5042 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5045 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
5046 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5048 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5049 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
5051 memc
->number_of_hosts
= number_of_hosts
;
5053 return TEST_SUCCESS
;
5056 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5058 memcached_server_instance_st instance_one
;
5059 memcached_server_instance_st instance_two
;
5061 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
5062 return TEST_SKIPPED
;
5064 test_compare(MEMCACHED_SUCCESS
,
5065 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
5067 const unsigned int max_keys
= 100;
5068 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
5069 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5071 for (unsigned int x
= 0; x
< max_keys
; ++x
)
5075 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5078 test_compare(MEMCACHED_SUCCESS
,
5079 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
5083 ** We are using the quiet commands to store the replicas, so we need
5084 ** to ensure that all of them are processed before we can continue.
5085 ** In the test we go directly from storing the object to trying to
5086 ** receive the object from all of the different servers, so we
5087 ** could end up in a race condition (the memcached server hasn't yet
5088 ** processed the quiet command from the replication set when it process
5089 ** the request from the other client (created by the clone)). As a
5090 ** workaround for that we call memcached_quit to send the quit command
5091 ** to the server and wait for the response ;-) If you use the test code
5092 ** as an example for your own code, please note that you shouldn't need
5095 memcached_quit(memc
);
5097 /* Verify that all messages are stored, and we didn't stuff too much
5100 test_compare(MEMCACHED_SUCCESS
,
5101 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5103 unsigned int counter
= 0;
5104 memcached_execute_fn callbacks
[]= { &callback_counter
};
5105 test_compare(MEMCACHED_SUCCESS
,
5106 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5108 /* Verify that we received all of the key/value pairs */
5109 test_compare(counter
, max_keys
);
5111 memcached_quit(memc
);
5113 * Don't do the following in your code. I am abusing the internal details
5114 * within the library, and this is not a supported interface.
5115 * This is to verify correct behavior in the library. Fake that two servers
5118 instance_one
= memcached_server_instance_by_position(memc
, 0);
5119 instance_two
= memcached_server_instance_by_position(memc
, 2);
5120 in_port_t port0
= instance_one
->port
;
5121 in_port_t port2
= instance_two
->port
;
5123 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5124 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5126 test_compare(MEMCACHED_SUCCESS
,
5127 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5130 test_compare(MEMCACHED_SUCCESS
,
5131 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5132 test_compare(counter
, (unsigned int)max_keys
);
5134 /* restore the memc handle */
5135 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5136 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5138 memcached_quit(memc
);
5140 /* Remove half of the objects */
5141 for (size_t x
= 0; x
< max_keys
; ++x
)
5145 test_compare(MEMCACHED_SUCCESS
,
5146 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
5150 memcached_quit(memc
);
5151 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5152 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5154 /* now retry the command, this time we should have cache misses */
5155 test_compare(MEMCACHED_SUCCESS
,
5156 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5159 test_compare(MEMCACHED_SUCCESS
,
5160 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5161 test_compare(counter
, (unsigned int)(max_keys
>> 1));
5163 /* Release allocated resources */
5164 for (size_t x
= 0; x
< max_keys
; ++x
)
5171 /* restore the memc handle */
5172 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5173 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5175 return TEST_SUCCESS
;
5178 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5180 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5181 test_true(memc_clone
);
5182 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5184 memcached_server_instance_st instance
=
5185 memcached_server_instance_by_position(memc_clone
, 0);
5187 if (instance
->major_version
> 1 ||
5188 (instance
->major_version
== 1 &&
5189 instance
->minor_version
> 2))
5191 /* Binary protocol doesn't support deferred delete */
5192 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5193 test_true(bin_clone
);
5194 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5195 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
5196 memcached_free(bin_clone
);
5198 memcached_quit(memc_clone
);
5200 /* If we know the server version, deferred delete should fail
5201 * with invalid arguments */
5202 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
5204 /* If we don't know the server version, we should get a protocol error */
5205 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5207 /* but there is a bug in some of the memcached servers (1.4) that treats
5208 * the counter as noreply so it doesn't send the proper error message
5210 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5212 /* And buffered mode should be disabled and we should get protocol error */
5213 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5214 rc
= memcached_delete(memc
, "foo", 3, 1);
5215 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5217 /* Same goes for noreply... */
5218 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5219 rc
= memcached_delete(memc
, "foo", 3, 1);
5220 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5222 /* but a normal request should go through (and be buffered) */
5223 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
5224 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
5226 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
5227 /* unbuffered noreply should be success */
5228 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
5229 /* unbuffered with reply should be not found... */
5230 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5231 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
5234 memcached_free(memc_clone
);
5235 return TEST_SUCCESS
;
5239 /* Test memcached_server_get_last_disconnect
5240 * For a working server set, shall be NULL
5241 * For a set of non existing server, shall not be NULL
5243 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5245 memcached_return_t rc
;
5246 memcached_server_instance_st disconnected_server
;
5248 /* With the working set of server */
5249 const char *key
= "marmotte";
5250 const char *value
= "milka";
5252 memcached_reset_last_disconnected_server(memc
);
5253 test_false(memc
->last_disconnected_server
);
5254 rc
= memcached_set(memc
, key
, strlen(key
),
5255 value
, strlen(value
),
5256 (time_t)0, (uint32_t)0);
5257 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5259 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5260 test_false(disconnected_server
);
5262 /* With a non existing server */
5264 memcached_server_st
*servers
;
5266 const char *server_list
= "localhost:9";
5268 servers
= memcached_servers_parse(server_list
);
5270 mine
= memcached_create(NULL
);
5271 rc
= memcached_server_push(mine
, servers
);
5272 test_compare(MEMCACHED_SUCCESS
, rc
);
5273 memcached_server_list_free(servers
);
5276 rc
= memcached_set(mine
, key
, strlen(key
),
5277 value
, strlen(value
),
5278 (time_t)0, (uint32_t)0);
5279 test_true(memcached_failed(rc
));
5281 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5282 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5283 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5284 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5286 memcached_quit(mine
);
5287 memcached_free(mine
);
5289 return TEST_SUCCESS
;
5292 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5294 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5295 char buffer
[BUFSIZ
];
5297 test_compare(MEMCACHED_SUCCESS
,
5298 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5300 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5303 // We will just use the error strings as our keys
5304 uint32_t counter
= 100;
5307 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5309 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5310 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5311 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
5313 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5314 test_true(disconnected_server
);
5315 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5316 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5320 memcached_reset_last_disconnected_server(memc
);
5325 memcached_free(memc
);
5327 return TEST_SUCCESS
;
5330 static test_return_t
test_verbosity(memcached_st
*memc
)
5332 memcached_verbosity(memc
, 3);
5334 return TEST_SUCCESS
;
5338 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5339 const char *key
, size_t key_length
,
5340 const char *value
, size_t value_length
,
5350 return MEMCACHED_SUCCESS
;
5353 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5355 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5356 test_compare(MEMCACHED_SUCCESS
, rc
);
5358 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5359 test_compare(MEMCACHED_SUCCESS
, rc
);
5361 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5362 test_compare(MEMCACHED_SUCCESS
, rc
);
5364 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5365 test_compare(MEMCACHED_SUCCESS
, rc
);
5367 return TEST_SUCCESS
;
5371 * This test ensures that the failure counter isn't incremented during
5372 * normal termination of the memcached instance.
5374 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5376 memcached_return_t rc
;
5377 memcached_server_instance_st instance
;
5379 /* Set value to force connection to the server */
5380 const char *key
= "marmotte";
5381 const char *value
= "milka";
5384 * Please note that I'm abusing the internal structures in libmemcached
5385 * in a non-portable way and you shouldn't be doing this. I'm only
5386 * doing this in order to verify that the library works the way it should
5388 uint32_t number_of_hosts
= memcached_server_count(memc
);
5389 memc
->number_of_hosts
= 1;
5391 /* Ensure that we are connected to the server by setting a value */
5392 rc
= memcached_set(memc
, key
, strlen(key
),
5393 value
, strlen(value
),
5394 (time_t)0, (uint32_t)0);
5395 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5398 instance
= memcached_server_instance_by_position(memc
, 0);
5399 /* The test is to see that the memcached_quit doesn't increase the
5400 * the server failure conter, so let's ensure that it is zero
5401 * before sending quit
5403 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5405 memcached_quit(memc
);
5407 /* Verify that it memcached_quit didn't increment the failure counter
5408 * Please note that this isn't bullet proof, because an error could
5411 test_zero(instance
->server_failure_counter
);
5413 /* restore the instance */
5414 memc
->number_of_hosts
= number_of_hosts
;
5416 return TEST_SUCCESS
;
5420 * This tests ensures expected disconnections (for some behavior changes
5421 * for instance) do not wrongly increase failure counter
5423 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5425 memcached_return rc
;
5427 memcached_st
*memc_clone
;
5428 memc_clone
= memcached_clone(NULL
, memc
);
5429 test_true(memc_clone
);
5431 /* Set value to force connection to the server */
5432 const char *key
= "marmotte";
5433 const char *value
= "milka";
5434 char *string
= NULL
;
5435 size_t string_length
;
5438 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5439 value
, strlen(value
),
5440 (time_t)0, (uint32_t)0);
5441 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5444 /* put failure limit to 1 */
5445 test_compare(MEMCACHED_SUCCESS
,
5446 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1));
5448 /* Put a retry timeout to effectively activate failure_limit effect */
5449 test_compare(MEMCACHED_SUCCESS
,
5450 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
5452 /* change behavior that triggers memcached_quit()*/
5453 test_compare(MEMCACHED_SUCCESS
,
5454 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5457 /* Check if we still are connected */
5458 string
= memcached_get(memc_clone
, key
, strlen(key
),
5459 &string_length
, &flags
, &rc
);
5461 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5464 memcached_free(memc_clone
);
5466 return TEST_SUCCESS
;
5473 * Test that ensures mget_execute does not end into recursive calls that finally fails
5475 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5477 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5478 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5479 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5480 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5481 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5484 return TEST_SKIPPED
; // My MAC can't handle this test
5488 * I only want to hit _one_ server so I know the number of requests I'm
5489 * sending in the pipeline.
5491 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5492 memc
->number_of_hosts
= 1;
5493 size_t max_keys
= 20480;
5496 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5497 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5499 /* First add all of the items.. */
5500 char blob
[1024]= { 0 };
5501 for (size_t x
= 0; x
< max_keys
; ++x
)
5504 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5507 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5508 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5513 /* Try to get all of them with a large multiget */
5515 memcached_execute_function callbacks
[]= { &callback_counter
};
5516 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5517 (size_t)max_keys
, callbacks
, &counter
, 1);
5518 test_compare(MEMCACHED_SUCCESS
, rc
);
5520 char* the_value
= NULL
;
5521 char the_key
[MEMCACHED_MAX_KEY
];
5522 size_t the_key_length
;
5523 size_t the_value_length
;
5527 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5529 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5535 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5538 test_compare(MEMCACHED_END
, rc
);
5540 /* Verify that we got all of the items */
5541 test_compare(counter
, max_keys
);
5544 /* Release all allocated resources */
5545 for (size_t x
= 0; x
< max_keys
; ++x
)
5552 memc
->number_of_hosts
= number_of_hosts
;
5554 return TEST_SUCCESS
;
5557 static test_return_t
regression_bug_583031(memcached_st
*)
5559 memcached_st
*memc
= memcached_create(NULL
);
5561 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5563 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5564 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5565 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5566 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5567 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5568 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5570 memcached_return_t rc
;
5574 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5578 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5580 memcached_free(memc
);
5582 return TEST_SUCCESS
;
5585 static test_return_t
regression_bug_581030(memcached_st
*)
5588 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5589 test_false(local_stat
);
5591 memcached_stat_free(NULL
, NULL
);
5594 return TEST_SUCCESS
;
5597 #define regression_bug_655423_COUNT 6000
5598 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5600 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5601 memc
= NULL
; // Just to make sure it is not used
5606 return TEST_SKIPPED
;
5609 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5610 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5611 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5612 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5614 memset(payload
, int('x'), sizeof(payload
));
5616 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5618 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5619 snprintf(key
, sizeof(key
), "%u", x
);
5621 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5624 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5626 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5627 snprintf(key
, sizeof(key
), "%u", x
);
5629 size_t value_length
;
5630 memcached_return_t rc
;
5631 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5633 if (rc
== MEMCACHED_NOTFOUND
)
5636 test_zero(value_length
);
5640 test_compare(MEMCACHED_SUCCESS
, rc
);
5642 test_compare(100LLU, value_length
);
5646 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5647 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5648 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5650 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5651 snprintf(key
, sizeof(key
), "%u", x
);
5653 keys
[x
]= strdup(key
);
5655 key_length
[x
]= strlen(key
);
5656 test_true(key_length
[x
]);
5659 test_compare(MEMCACHED_SUCCESS
,
5660 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5663 memcached_result_st
*result
= NULL
;
5664 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5666 test_compare(size_t(100), memcached_result_length(result
));
5670 test_true(count
> 100); // If we don't get back atleast this, something is up
5672 /* Release all allocated resources */
5673 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5681 memcached_free(clone
);
5683 return TEST_SUCCESS
;
5687 * Test that ensures that buffered set to not trigger problems during io_flush
5689 #define regression_bug_490520_COUNT 200480
5690 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5692 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5693 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5694 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5695 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5696 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5698 memc
->number_of_hosts
= 1;
5700 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5701 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5703 /* First add all of the items.. */
5704 char blob
[3333] = {0};
5705 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5708 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5712 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5713 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5716 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5723 return TEST_SUCCESS
;
5727 static test_return_t
regression_bug_854604(memcached_st
*)
5731 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
5733 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
5735 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
5736 test_compare(buffer
[0], 0);
5738 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
5739 test_true(strlen(buffer
));
5741 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
5742 test_true(strlen(buffer
));
5744 return TEST_SUCCESS
;
5747 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5749 fprintf(stderr
, "Iteration #%u: ", it
);
5751 if (error
== MEMCACHED_ERRNO
)
5753 fprintf(stderr
, "system error %d from %s: %s\n",
5754 errno
, what
, strerror(errno
));
5758 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5759 memcached_strerror(mc
, error
));
5763 #define TEST_CONSTANT_CREATION 200
5765 static test_return_t
regression_bug_(memcached_st
*memc
)
5767 const char *remote_server
;
5770 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5772 return TEST_SKIPPED
;
5775 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5777 memcached_st
* mc
= memcached_create(NULL
);
5778 memcached_return rc
;
5780 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5781 if (rc
!= MEMCACHED_SUCCESS
)
5783 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5786 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5787 if (rc
!= MEMCACHED_SUCCESS
)
5789 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5792 rc
= memcached_server_add(mc
, remote_server
, 0);
5793 if (rc
!= MEMCACHED_SUCCESS
)
5795 memcached_die(mc
, rc
, "memcached_server_add", x
);
5798 const char *set_key
= "akey";
5799 const size_t set_key_len
= strlen(set_key
);
5800 const char *set_value
= "a value";
5801 const size_t set_value_len
= strlen(set_value
);
5803 if (rc
== MEMCACHED_SUCCESS
)
5807 size_t get_value_len
;
5809 uint32_t get_value_flags
;
5811 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5812 &get_value_flags
, &rc
);
5813 if (rc
!= MEMCACHED_SUCCESS
)
5815 memcached_die(mc
, rc
, "memcached_get", x
);
5821 (get_value_len
!= set_value_len
5822 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5824 fprintf(stderr
, "Values don't match?\n");
5825 rc
= MEMCACHED_FAILURE
;
5831 rc
= memcached_set(mc
,
5832 set_key
, set_key_len
,
5833 set_value
, set_value_len
,
5837 if (rc
!= MEMCACHED_SUCCESS
)
5839 memcached_die(mc
, rc
, "memcached_set", x
);
5846 if (rc
!= MEMCACHED_SUCCESS
)
5852 return TEST_SUCCESS
;
5855 /* Clean the server before beginning testing */
5857 {"util_version", true, (test_callback_fn
*)util_version_test
},
5858 {"flush", false, (test_callback_fn
*)flush_test
},
5859 {"init", false, (test_callback_fn
*)init_test
},
5860 {"allocation", false, (test_callback_fn
*)allocation_test
},
5861 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5862 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5863 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5864 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5865 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5866 {"clone_test", false, (test_callback_fn
*)clone_test
},
5867 {"connection_test", false, (test_callback_fn
*)connection_test
},
5868 {"callback_test", false, (test_callback_fn
*)callback_test
},
5869 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5870 {"set", false, (test_callback_fn
*)set_test
},
5871 {"set2", false, (test_callback_fn
*)set_test2
},
5872 {"set3", false, (test_callback_fn
*)set_test3
},
5873 {"dump", true, (test_callback_fn
*)dump_test
},
5874 {"add", true, (test_callback_fn
*)add_test
},
5875 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5876 {"replace", true, (test_callback_fn
*)replace_test
},
5877 {"delete", true, (test_callback_fn
*)delete_test
},
5878 {"get", true, (test_callback_fn
*)get_test
},
5879 {"get2", false, (test_callback_fn
*)get_test2
},
5880 {"get3", false, (test_callback_fn
*)get_test3
},
5881 {"get4", false, (test_callback_fn
*)get_test4
},
5882 {"partial mget", false, (test_callback_fn
*)get_test5
},
5883 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5884 {"increment", false, (test_callback_fn
*)increment_test
},
5885 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5886 {"decrement", false, (test_callback_fn
*)decrement_test
},
5887 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5888 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5889 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5890 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5891 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5892 {"binary_increment_with_prefix", 1, (test_callback_fn
*)binary_increment_with_prefix_test
},
5893 {"quit", false, (test_callback_fn
*)quit_test
},
5894 {"mget", true, (test_callback_fn
*)mget_test
},
5895 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5896 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5897 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5898 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5899 {"mget_end", false, (test_callback_fn
*)mget_end
},
5900 {"get_stats", false, (test_callback_fn
*)get_stats
},
5901 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5902 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5903 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5904 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
5905 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5906 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5907 {"read_through", true, (test_callback_fn
*)read_through
},
5908 {"delete_through", true, (test_callback_fn
*)delete_through
},
5909 {"noreply", true, (test_callback_fn
*)noreply_test
},
5910 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5911 {"memcached_pool_st", true, (test_callback_fn
*)connection_pool_test
},
5912 {"memcached_pool_st #2", true, (test_callback_fn
*)connection_pool2_test
},
5913 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
5914 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
5915 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
5916 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
5917 {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_NOTFOUND
},
5918 {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_SUCCESS
},
5919 {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_by_key_NOTFOUND
},
5920 {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_by_key_SUCCESS
},
5924 test_st behavior_tests
[] ={
5925 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5926 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5927 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5928 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5929 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5930 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5931 {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test
},
5935 test_st libmemcachedutil_tests
[] ={
5936 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5937 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5938 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5942 test_st basic_tests
[] ={
5943 {"init", true, (test_callback_fn
*)basic_init_test
},
5944 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5945 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5946 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5947 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5948 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5949 {"memcached_return_t", false, (test_callback_fn
*)memcached_return_t_TEST
},
5953 test_st regression_binary_vs_block
[] ={
5954 {"block add", true, (test_callback_fn
*)block_add_regression
},
5955 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
5959 test_st async_tests
[] ={
5960 {"add", true, (test_callback_fn
*)add_wrapper
},
5964 test_st memcached_server_get_last_disconnect_tests
[] ={
5965 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
5966 {0, 0, (test_callback_fn
*)0}
5970 test_st result_tests
[] ={
5971 {"result static", false, (test_callback_fn
*)result_static
},
5972 {"result alloc", false, (test_callback_fn
*)result_alloc
},
5973 {0, 0, (test_callback_fn
*)0}
5976 test_st version_1_2_3
[] ={
5977 {"append", false, (test_callback_fn
*)append_test
},
5978 {"prepend", false, (test_callback_fn
*)prepend_test
},
5979 {"cas", false, (test_callback_fn
*)cas_test
},
5980 {"cas2", false, (test_callback_fn
*)cas2_test
},
5981 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
5982 {0, 0, (test_callback_fn
*)0}
5985 test_st haldenbrand_tests
[] ={
5986 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
5987 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
5988 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
5989 {0, 0, (test_callback_fn
*)0}
5992 test_st user_tests
[] ={
5993 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
5994 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
5995 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
5996 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
5997 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
5998 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
5999 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
6000 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
6001 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
6002 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
6003 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
6004 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
6005 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
6006 #if !defined(__sun) && !defined(__OpenBSD__)
6008 ** It seems to be something weird with the character sets..
6009 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6010 ** guess I need to find out how this is supposed to work.. Perhaps I need
6011 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6012 ** so just disable the code for now...).
6014 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
6016 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
6017 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
6018 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
6019 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
6020 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
6021 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
6022 {0, 0, (test_callback_fn
*)0}
6025 test_st replication_tests
[]= {
6026 {"set", true, (test_callback_fn
*)replication_set_test
},
6027 {"get", false, (test_callback_fn
*)replication_get_test
},
6028 {"mget", false, (test_callback_fn
*)replication_mget_test
},
6029 {"delete", true, (test_callback_fn
*)replication_delete_test
},
6030 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
6031 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
6032 {0, 0, (test_callback_fn
*)0}
6036 * The following test suite is used to verify that we don't introduce
6037 * regression bugs. If you want more information about the bug / test,
6038 * you should look in the bug report at
6039 * http://bugs.launchpad.net/libmemcached
6041 test_st regression_tests
[]= {
6042 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
6043 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
6044 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
6045 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
6046 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
6047 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
6048 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
6049 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
6050 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
6051 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
6052 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
6053 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
6054 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
6055 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
6056 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
6057 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
6058 {"lp:854604", true, (test_callback_fn
*)regression_bug_854604
},
6059 {0, false, (test_callback_fn
*)0}
6062 test_st ketama_compatibility
[]= {
6063 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
6064 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
6065 {0, 0, (test_callback_fn
*)0}
6068 test_st generate_tests
[] ={
6069 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6070 {"generate_data", true, (test_callback_fn
*)generate_data
},
6071 {"get_read", false, (test_callback_fn
*)get_read
},
6072 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
6073 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
6074 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
6075 {"generate_data", true, (test_callback_fn
*)generate_data
},
6076 {"mget_read", false, (test_callback_fn
*)mget_read
},
6077 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
6078 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
6079 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
6080 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
6081 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6082 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
6083 {"generate_data", true, (test_callback_fn
*)generate_data
},
6084 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
6085 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6086 {0, 0, (test_callback_fn
*)0}
6089 test_st consistent_tests
[] ={
6090 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6091 {"generate_data", true, (test_callback_fn
*)generate_data
},
6092 {"get_read", 0, (test_callback_fn
*)get_read_count
},
6093 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6094 {0, 0, (test_callback_fn
*)0}
6097 test_st consistent_weighted_tests
[] ={
6098 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6099 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
6100 {"get_read", false, (test_callback_fn
*)get_read_count
},
6101 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6102 {0, 0, (test_callback_fn
*)0}
6105 test_st hsieh_availability
[] ={
6106 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
6107 {0, 0, (test_callback_fn
*)0}
6110 test_st murmur_availability
[] ={
6111 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
6112 {0, 0, (test_callback_fn
*)0}
6116 test_st hash_sanity
[] ={
6117 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
6118 {0, 0, (test_callback_fn
*)0}
6122 test_st ketama_auto_eject_hosts
[] ={
6123 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
6124 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
6125 {0, 0, (test_callback_fn
*)0}
6128 test_st hash_tests
[] ={
6129 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
6130 {"md5", false, (test_callback_fn
*)md5_run
},
6131 {"crc", false, (test_callback_fn
*)crc_run
},
6132 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
6133 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
6134 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
6135 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
6136 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
6137 {"murmur", false, (test_callback_fn
*)murmur_run
},
6138 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
6139 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
6140 {0, 0, (test_callback_fn
*)0}
6143 test_st error_conditions
[] ={
6144 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
6145 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
6146 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
6147 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6148 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6149 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
6150 {0, 0, (test_callback_fn
*)0}
6154 test_st parser_tests
[] ={
6155 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
6156 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
6157 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
6158 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
6159 {"hash", false, (test_callback_fn
*)parser_hash_test
},
6160 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
6161 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
6162 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
6163 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
6164 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
6165 {"server", false, (test_callback_fn
*)server_test
},
6166 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
6167 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
6168 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
6169 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
6170 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
6171 {0, 0, (test_callback_fn
*)0}
6174 test_st virtual_bucket_tests
[] ={
6175 {"basic", false, (test_callback_fn
*)virtual_back_map
},
6176 {0, 0, (test_callback_fn
*)0}
6179 test_st memcached_server_add_tests
[] ={
6180 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
6181 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
6182 {0, 0, (test_callback_fn
*)0}
6185 test_st namespace_tests
[] ={
6186 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
6187 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
6188 {0, 0, (test_callback_fn
*)0}
6191 collection_st collection
[] ={
6193 {"hash_sanity", 0, 0, hash_sanity
},
6195 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
6196 {"basic", 0, 0, basic_tests
},
6197 {"hsieh_availability", 0, 0, hsieh_availability
},
6198 {"murmur_availability", 0, 0, murmur_availability
},
6199 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
6200 {"block", 0, 0, tests
},
6201 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
6202 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
6203 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6204 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
6205 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
6206 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
6207 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
6208 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
6209 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
6210 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
6211 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
6212 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
6213 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
6214 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6215 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
6216 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6217 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
6218 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
6219 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
6220 #ifdef MEMCACHED_ENABLE_DEPRECATED
6221 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
6223 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
6224 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
6225 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
6226 {"specific namespace", 0, 0, namespace_tests
},
6227 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
6228 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
6229 {"result", 0, 0, result_tests
},
6230 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
6231 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
6232 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
6233 {"user written tests", 0, 0, user_tests
},
6234 {"generate", 0, 0, generate_tests
},
6235 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
6236 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
6237 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
6238 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
6239 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
6240 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
6241 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
6243 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
6244 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
6245 {"consistent_not", 0, 0, consistent_tests
},
6246 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
6247 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6248 {"ketama_compat", 0, 0, ketama_compatibility
},
6249 {"test_hashes", 0, 0, hash_tests
},
6250 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6251 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6252 {"regression", 0, 0, regression_tests
},
6253 {"behaviors", 0, 0, behavior_tests
},
6254 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6255 {"error_conditions", 0, 0, error_conditions
},
6256 {"parser", 0, 0, parser_tests
},
6257 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6258 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6262 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
6264 #include "tests/libmemcached_world.h"
6266 void get_world(Framework
*world
)
6268 world
->collections
= collection
;
6270 world
->_create
= (test_callback_create_fn
*)world_create
;
6271 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6273 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6274 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6275 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6276 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6277 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6279 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6280 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6282 world
->set_runner(&defualt_libmemcached_runner
);
6284 world
->set_socket();