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>
41 #if defined(HAVE_LIBUUID) && HAVE_LIBUUID
42 #include <uuid/uuid.h>
49 #include <libmemcached-1.0/memcached.h>
50 #include <libmemcached/is.h>
51 #include <libmemcached/server_instance.h>
53 #include <libhashkit-1.0/hashkit.h>
59 #include <semaphore.h>
63 #include <sys/types.h>
68 #include <libtest/server.h>
70 #include "clients/generator.h"
72 #define SMALL_STRING_LEN 1024
74 #include <libtest/test.hpp>
76 using namespace libtest
;
78 #include <libmemcached/util.h>
80 #include "tests/hash_results.h"
82 #include "tests/libmemcached-1.0/servers_to_create.h"
84 #include "tests/libmemcached-1.0/callback_counter.h"
85 #include "tests/libmemcached-1.0/fetch_all_results.h"
86 #include "tests/libmemcached-1.0/mem_functions.h"
87 #include "tests/libmemcached-1.0/setup_and_teardowns.h"
88 #include "tests/print.h"
89 #include "tests/debug.h"
91 #define UUID_STRING_MAXLENGTH 36
97 init(arg
, UUID_STRING_MAXLENGTH
);
100 keys_st(size_t arg
, size_t padding
)
105 void init(size_t arg
, size_t padding
)
107 _lengths
.resize(arg
);
110 for (size_t x
= 0; x
< _keys
.size(); x
++)
112 libtest::vchar_t key_buffer
;
113 key_buffer
.resize(padding
+1);
114 memset(&key_buffer
[0], 'x', padding
);
121 uuid_unparse(out
, &key_buffer
[0]);
122 _keys
[x
]= strdup(&key_buffer
[0]);
123 (_keys
[x
])[UUID_STRING_MAXLENGTH
]= 'x';
125 else // We just use a number and pad the string if UUID is not available
127 char int_buffer
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
128 int key_length
= snprintf(int_buffer
, sizeof(int_buffer
), "%u", uint32_t(x
));
129 memcpy(&key_buffer
[0], int_buffer
, key_length
);
130 _keys
[x
]= strdup(&key_buffer
[0]);
132 _lengths
[x
]= padding
;
138 for (libtest::vchar_ptr_t::iterator iter
= _keys
.begin();
146 libtest::vchar_ptr_t::iterator
begin()
148 return _keys
.begin();
151 libtest::vchar_ptr_t::iterator
end()
161 std::vector
<size_t>& lengths()
166 libtest::vchar_ptr_t
& keys()
171 size_t* lengths_ptr()
181 char* key_at(size_t arg
)
186 size_t length_at(size_t arg
)
188 return _lengths
[arg
];
192 libtest::vchar_ptr_t _keys
;
193 std::vector
<size_t> _lengths
;
196 static memcached_return_t
return_value_based_on_buffering(memcached_st
*memc
)
198 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
))
200 return MEMCACHED_BUFFERED
;
203 return MEMCACHED_SUCCESS
;
206 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
209 * I only want to hit _one_ server so I know the number of requests I'm
210 * sending in the pipeline.
212 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
214 char server_string
[1024];
215 int server_string_length
;
218 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
219 memcached_server_name(instance
), int(memcached_server_port(instance
)),
224 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
225 memcached_server_name(instance
), int(memcached_server_port(instance
)));
228 if (server_string_length
<= 0)
234 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, buffer
, sizeof(buffer
))))
236 Error
<< "Failed to parse " << server_string_length
;
240 return memcached(server_string
, server_string_length
);
244 test_return_t
init_test(memcached_st
*not_used
)
249 (void)memcached_create(&memc
);
250 memcached_free(&memc
);
255 #define TEST_PORT_COUNT 7
256 in_port_t test_ports
[TEST_PORT_COUNT
];
258 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
259 const memcached_server_st
*server
,
263 size_t bigger
= *((size_t *)(context
));
265 assert(bigger
<= memcached_server_port(server
));
266 *((size_t *)(context
))= memcached_server_port(server
);
268 return MEMCACHED_SUCCESS
;
271 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
272 const memcached_server_st
*instance
,
276 FILE *stream
= (FILE *)context
;
279 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
280 memcached_server_name(instance
),
281 memcached_server_port(instance
),
282 instance
->major_version
,
283 instance
->minor_version
,
284 instance
->micro_version
);
286 return MEMCACHED_SUCCESS
;
289 test_return_t
server_sort_test(memcached_st
*ptr
)
291 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
293 memcached_return_t rc
;
294 memcached_server_fn callbacks
[1];
295 memcached_st
*local_memc
;
298 local_memc
= memcached_create(NULL
);
299 test_true(local_memc
);
300 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
302 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
304 test_ports
[x
]= (in_port_t
)random() % 64000;
305 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
306 test_compare(memcached_server_count(local_memc
), x
+1);
308 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
310 test_compare(MEMCACHED_SUCCESS
, rc
);
313 callbacks
[0]= server_display_function
;
314 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
317 memcached_free(local_memc
);
322 test_return_t
server_sort2_test(memcached_st
*ptr
)
324 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
325 memcached_server_fn callbacks
[1];
326 memcached_st
*local_memc
;
327 memcached_server_instance_st instance
;
330 local_memc
= memcached_create(NULL
);
331 test_true(local_memc
);
332 test_compare(MEMCACHED_SUCCESS
,
333 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
335 test_compare(MEMCACHED_SUCCESS
,
336 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
337 instance
= memcached_server_instance_by_position(local_memc
, 0);
338 test_compare(in_port_t(43043), memcached_server_port(instance
));
340 test_compare(MEMCACHED_SUCCESS
,
341 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
343 instance
= memcached_server_instance_by_position(local_memc
, 0);
344 test_compare(in_port_t(43042), memcached_server_port(instance
));
346 instance
= memcached_server_instance_by_position(local_memc
, 1);
347 test_compare(in_port_t(43043), memcached_server_port(instance
));
349 callbacks
[0]= server_display_function
;
350 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
353 memcached_free(local_memc
);
358 test_return_t
memcached_server_remove_test(memcached_st
*)
360 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";
363 test_compare(MEMCACHED_SUCCESS
,
364 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
365 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
368 memcached_server_fn callbacks
[1];
369 callbacks
[0]= server_print_callback
;
370 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
372 memcached_free(memc
);
377 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
378 const memcached_server_st
*server
,
382 uint32_t x
= *((uint32_t *)(context
));
384 if (! (test_ports
[x
] == server
->port
))
386 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
387 return MEMCACHED_FAILURE
;
390 *((uint32_t *)(context
))= ++x
;
392 return MEMCACHED_SUCCESS
;
395 test_return_t
server_unsort_test(memcached_st
*ptr
)
397 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
398 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
399 memcached_server_fn callbacks
[1];
400 memcached_st
*local_memc
;
403 local_memc
= memcached_create(NULL
);
404 test_true(local_memc
);
406 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
408 test_ports
[x
]= (in_port_t
)(random() % 64000);
409 test_compare(MEMCACHED_SUCCESS
,
410 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
411 test_compare(memcached_server_count(local_memc
), x
+1);
413 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
417 callbacks
[0]= server_display_unsort_function
;
418 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
420 /* Now we sort old data! */
421 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
422 callbacks
[0]= server_display_function
;
423 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
426 memcached_free(local_memc
);
431 test_return_t
allocation_test(memcached_st
*not_used
)
435 memc
= memcached_create(NULL
);
437 memcached_free(memc
);
442 test_return_t
clone_test(memcached_st
*memc
)
446 memcached_st
*memc_clone
;
447 memc_clone
= memcached_clone(NULL
, NULL
);
448 test_true(memc_clone
);
449 memcached_free(memc_clone
);
452 /* Can we init from null? */
454 memcached_st
*memc_clone
;
455 memc_clone
= memcached_clone(NULL
, memc
);
456 test_true(memc_clone
);
459 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
460 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
461 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
462 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
465 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
466 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
467 test_true(memc_clone
->distribution
== memc
->distribution
);
468 { // Test all of the flags
469 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
470 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
471 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
472 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
473 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
474 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
475 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
476 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
477 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
478 test_true(memc_clone
->flags
.reply
== memc
->flags
.reply
);
479 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
480 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
481 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
483 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
484 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
485 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
486 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
487 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
488 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
489 test_true(memc_clone
->on_clone
== memc
->on_clone
);
490 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
491 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
492 test_true(memc_clone
->recv_size
== memc
->recv_size
);
493 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
494 test_true(memc_clone
->send_size
== memc
->send_size
);
495 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
496 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
497 test_true(memc_clone
->user_data
== memc
->user_data
);
499 memcached_free(memc_clone
);
502 /* Can we init from struct? */
504 memcached_st declared_clone
;
505 memcached_st
*memc_clone
;
506 memset(&declared_clone
, 0 , sizeof(memcached_st
));
507 memc_clone
= memcached_clone(&declared_clone
, NULL
);
508 test_true(memc_clone
);
509 memcached_free(memc_clone
);
512 /* Can we init from struct? */
514 memcached_st declared_clone
;
515 memcached_st
*memc_clone
;
516 memset(&declared_clone
, 0 , sizeof(memcached_st
));
517 memc_clone
= memcached_clone(&declared_clone
, memc
);
518 test_true(memc_clone
);
519 memcached_free(memc_clone
);
525 test_return_t
userdata_test(memcached_st
*memc
)
528 test_false(memcached_set_user_data(memc
, foo
));
529 test_true(memcached_get_user_data(memc
) == foo
);
530 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
535 test_return_t
connection_test(memcached_st
*memc
)
537 test_compare(MEMCACHED_SUCCESS
,
538 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
543 test_return_t
libmemcached_string_behavior_test(memcached_st
*)
545 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
547 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
549 test_compare(37, int(MEMCACHED_BEHAVIOR_MAX
));
554 test_return_t
libmemcached_string_distribution_test(memcached_st
*)
556 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
558 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
560 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
565 test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
567 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
568 982370485U, 1263635348U, 4242906218U, 3829656100U,
569 1891735253U, 334139633U, 2257084983U, 3351789013U,
570 13199785U, 2542027183U, 1097051614U, 199566778U,
571 2748246961U, 2465192557U, 1664094137U, 2405439045U,
572 1842224848U, 692413798U, 3479807801U, 919913813U,
573 4269430871U, 610793021U, 527273862U, 1437122909U,
574 2300930706U, 2943759320U, 674306647U, 2400528935U,
575 54481931U, 4186304426U, 1741088401U, 2979625118U,
576 4159057246U, 3425930182U, 2593724503U, 1868899624U,
577 1769812374U, 2302537950U, 1110330676U, 3365377466U,
578 1336171666U, 3021258493U, 2334992265U, 3861994737U,
579 3582734124U, 3365377466U };
581 // You have updated the memcache_error messages but not updated docs/tests.
582 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
585 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
586 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
587 MEMCACHED_HASH_JENKINS
);
588 if (values
[rc
] != hash_val
)
590 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
591 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
593 test_compare(values
[rc
], hash_val
);
595 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
600 test_return_t
set_test(memcached_st
*memc
)
602 memcached_return_t rc
= memcached_set(memc
,
603 test_literal_param("foo"),
604 test_literal_param("when we sanitize"),
605 time_t(0), (uint32_t)0);
606 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
611 test_return_t
append_test(memcached_st
*memc
)
613 memcached_return_t rc
;
614 const char *in_value
= "we";
618 test_compare(MEMCACHED_SUCCESS
,
619 memcached_flush(memc
, 0));
621 test_compare(MEMCACHED_SUCCESS
,
623 test_literal_param(__func__
),
624 in_value
, strlen(in_value
),
625 time_t(0), uint32_t(0)));
627 test_compare(MEMCACHED_SUCCESS
,
628 memcached_append(memc
,
629 test_literal_param(__func__
),
630 " the", strlen(" the"),
631 time_t(0), uint32_t(0)));
633 test_compare(MEMCACHED_SUCCESS
,
634 memcached_append(memc
,
635 test_literal_param(__func__
),
636 " people", strlen(" people"),
637 time_t(0), uint32_t(0)));
639 char *out_value
= memcached_get(memc
,
640 test_literal_param(__func__
),
641 &value_length
, &flags
, &rc
);
642 test_memcmp(out_value
, "we the people", strlen("we the people"));
643 test_compare(strlen("we the people"), value_length
);
644 test_compare(MEMCACHED_SUCCESS
, rc
);
650 test_return_t
append_binary_test(memcached_st
*memc
)
652 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
654 test_compare(MEMCACHED_SUCCESS
,
655 memcached_flush(memc
, 0));
657 test_compare(MEMCACHED_SUCCESS
,
659 test_literal_param(__func__
),
661 time_t(0), uint32_t(0)));
664 for (uint32_t x
= 0; store_list
[x
] ; x
++)
666 test_compare(MEMCACHED_SUCCESS
,
667 memcached_append(memc
,
668 test_literal_param(__func__
),
669 (char *)&store_list
[x
], sizeof(uint32_t),
670 time_t(0), uint32_t(0)));
676 memcached_return_t rc
;
677 uint32_t *value
= (uint32_t *)memcached_get(memc
,
678 test_literal_param(__func__
),
679 &value_length
, &flags
, &rc
);
680 test_compare(value_length
, sizeof(uint32_t) * count
);
681 test_compare(MEMCACHED_SUCCESS
, rc
);
683 for (uint32_t counter
= count
, *ptr
= value
; counter
; counter
--)
685 test_compare(*ptr
, store_list
[count
- counter
]);
693 test_return_t
memcached_mget_mixed_memcached_get_TEST(memcached_st
*memc
)
697 for (libtest::vchar_ptr_t::iterator iter
= keys
.begin();
701 test_compare(MEMCACHED_SUCCESS
,
705 time_t(0), uint32_t(0)));
708 for (size_t loop
= 0; loop
< 20; loop
++)
712 test_compare(MEMCACHED_SUCCESS
,
713 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
715 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
718 size_t result_count
= 0;
719 memcached_return_t rc
;
720 while (memcached_fetch_result(memc
, results
, &rc
))
724 test_compare(keys
.size(), result_count
);
728 int which_key
= random() %keys
.size();
731 memcached_return_t rc
;
732 char *out_value
= memcached_get(memc
, keys
.key_at(which_key
), keys
.length_at(which_key
),
733 &value_length
, &flags
, &rc
);
734 test_compare(MEMCACHED_SUCCESS
, rc
);
735 test_null(out_value
);
736 test_zero(value_length
);
744 test_return_t
cas2_test(memcached_st
*memc
)
746 const char *keys
[]= {"fudge", "son", "food"};
747 size_t key_length
[]= {5, 3, 4};
748 const char *value
= "we the people";
749 size_t value_length
= strlen("we the people");
751 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
753 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
755 for (uint32_t x
= 0; x
< 3; x
++)
757 test_compare(MEMCACHED_SUCCESS
,
758 memcached_set(memc
, keys
[x
], key_length
[x
],
759 keys
[x
], key_length
[x
],
760 time_t(50), uint32_t(9)));
763 test_compare(MEMCACHED_SUCCESS
,
764 memcached_mget(memc
, keys
, key_length
, 3));
766 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
769 memcached_return_t rc
;
770 results
= memcached_fetch_result(memc
, results
, &rc
);
772 test_true(results
->item_cas
);
773 test_compare(MEMCACHED_SUCCESS
, rc
);
774 test_true(memcached_result_cas(results
));
776 test_memcmp(value
, "we the people", strlen("we the people"));
777 test_compare(strlen("we the people"), value_length
);
778 test_compare(MEMCACHED_SUCCESS
, rc
);
780 memcached_result_free(results
);
785 test_return_t
cas_test(memcached_st
*memc
)
787 const char* keys
[2] = { __func__
, NULL
};
788 size_t keylengths
[2] = { strlen(__func__
), 0 };
790 memcached_result_st results_obj
;
792 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
794 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
796 test_compare(MEMCACHED_SUCCESS
,
798 test_literal_param(__func__
),
799 test_literal_param("we the people"),
800 (time_t)0, (uint32_t)0));
802 test_compare(MEMCACHED_SUCCESS
,
803 memcached_mget(memc
, keys
, keylengths
, 1));
805 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
808 memcached_return_t rc
;
809 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
811 test_compare(MEMCACHED_SUCCESS
, rc
);
812 test_true(memcached_result_cas(results
));
813 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
814 test_compare(test_literal_param_size("we the people"),
815 strlen(memcached_result_value(results
)));
817 uint64_t cas
= memcached_result_cas(results
);
820 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
821 test_true(rc
== MEMCACHED_END
);
822 test_true(results
== NULL
);
825 test_compare(MEMCACHED_SUCCESS
,
827 test_literal_param(__func__
),
828 test_literal_param("change the value"),
832 * The item will have a new cas value, so try to set it again with the old
833 * value. This should fail!
835 test_compare(MEMCACHED_DATA_EXISTS
,
837 test_literal_param(__func__
),
838 test_literal_param("change the value"),
841 memcached_result_free(&results_obj
);
847 test_return_t
prepend_test(memcached_st
*memc
)
849 const char *key
= "fig";
850 const char *value
= "people";
852 test_compare(MEMCACHED_SUCCESS
,
853 memcached_flush(memc
, 0));
855 test_compare(MEMCACHED_SUCCESS
,
856 memcached_set(memc
, key
, strlen(key
),
857 value
, strlen(value
),
858 time_t(0), uint32_t(0)));
860 test_compare(MEMCACHED_SUCCESS
,
861 memcached_prepend(memc
, key
, strlen(key
),
862 "the ", strlen("the "),
863 time_t(0), uint32_t(0)));
865 test_compare(MEMCACHED_SUCCESS
,
866 memcached_prepend(memc
, key
, strlen(key
),
867 "we ", strlen("we "),
868 time_t(0), uint32_t(0)));
872 memcached_return_t rc
;
873 char *out_value
= memcached_get(memc
, key
, strlen(key
),
874 &value_length
, &flags
, &rc
);
875 test_memcmp(out_value
, "we the people", strlen("we the people"));
876 test_compare(strlen("we the people"), value_length
);
877 test_compare(MEMCACHED_SUCCESS
, rc
);
884 Set the value, then quit to make sure it is flushed.
885 Come back in and test that add fails.
887 test_return_t
add_test(memcached_st
*memc
)
889 test_compare_hint(return_value_based_on_buffering(memc
),
891 test_literal_param(__func__
),
892 test_literal_param("when we sanitize"),
893 time_t(0), uint32_t(0)),
894 memcached_last_error_message(memc
));
896 memcached_quit(memc
);
898 test_compare_hint(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
900 test_literal_param(__func__
),
901 test_literal_param("try something else"),
902 time_t(0), uint32_t(0)),
903 memcached_last_error_message(memc
));
909 ** There was a problem of leaking filedescriptors in the initial release
910 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
911 ** systems it seems that the kernel is slow on reclaiming the resources
912 ** because the connects starts to time out (the test doesn't do much
913 ** anyway, so just loop 10 iterations)
915 test_return_t
add_wrapper(memcached_st
*memc
)
917 unsigned int max
= 10000;
925 for (uint32_t x
= 0; x
< max
; x
++)
931 test_return_t
replace_test(memcached_st
*memc
)
933 test_compare(return_value_based_on_buffering(memc
),
935 test_literal_param(__func__
),
936 test_literal_param("when we sanitize"),
937 time_t(0), uint32_t(0)));
939 test_compare(MEMCACHED_SUCCESS
,
940 memcached_replace(memc
,
941 test_literal_param(__func__
),
942 test_literal_param("first we insert some data"),
943 time_t(0), uint32_t(0)));
948 test_return_t
delete_test(memcached_st
*memc
)
950 test_compare(return_value_based_on_buffering(memc
),
952 test_literal_param(__func__
),
953 test_literal_param("when we sanitize"),
954 time_t(0), uint32_t(0)));
956 test_compare_hint(return_value_based_on_buffering(memc
),
957 memcached_delete(memc
,
958 test_literal_param(__func__
),
960 memcached_last_error_message(memc
));
965 test_return_t
flush_test(memcached_st
*memc
)
967 uint64_t query_id
= memcached_query_id(memc
);
968 test_compare(MEMCACHED_SUCCESS
,
969 memcached_flush(memc
, 0));
970 test_compare(query_id
+1, memcached_query_id(memc
));
975 static memcached_return_t
server_function(const memcached_st
*,
976 const memcached_server_st
*,
980 return MEMCACHED_SUCCESS
;
983 test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
986 strncpy(context
, "foo bad", sizeof(context
));
987 memcached_server_fn callbacks
[1];
989 callbacks
[0]= server_function
;
990 memcached_server_cursor(memc
, callbacks
, context
, 1);
994 test_return_t
bad_key_test(memcached_st
*memc
)
996 memcached_return_t rc
;
997 const char *key
= "foo bad";
1000 uint64_t query_id
= memcached_query_id(memc
);
1002 // Just skip if we are in binary mode.
1003 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1005 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
1007 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
1008 test_true(memc_clone
);
1010 query_id
= memcached_query_id(memc_clone
);
1011 test_compare(MEMCACHED_SUCCESS
,
1012 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1013 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
1015 /* All keys are valid in the binary protocol (except for length) */
1016 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == false)
1018 uint64_t before_query_id
= memcached_query_id(memc_clone
);
1020 size_t string_length
;
1021 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1022 &string_length
, &flags
, &rc
);
1023 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1024 test_zero(string_length
);
1027 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
1029 query_id
= memcached_query_id(memc_clone
);
1030 test_compare(MEMCACHED_SUCCESS
,
1031 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
1032 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
1034 size_t string_length
;
1035 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1036 &string_length
, &flags
, &rc
);
1037 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1038 test_zero(string_length
);
1042 /* Test multi key for bad keys */
1043 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
1044 size_t key_lengths
[] = { 7, 7, 7 };
1045 query_id
= memcached_query_id(memc_clone
);
1046 test_compare(MEMCACHED_SUCCESS
,
1047 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1048 test_compare(query_id
, memcached_query_id(memc_clone
));
1050 query_id
= memcached_query_id(memc_clone
);
1051 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
1052 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
1053 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1055 query_id
= memcached_query_id(memc_clone
);
1056 // Grouping keys are not required to follow normal key behaviors
1057 test_compare(MEMCACHED_SUCCESS
,
1058 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
1059 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1061 /* The following test should be moved to the end of this function when the
1062 memcached server is updated to allow max size length of the keys in the
1065 test_compare(MEMCACHED_SUCCESS
,
1066 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
1068 libtest::vchar_t longkey
;
1070 libtest::vchar_t::iterator it
= longkey
.begin();
1071 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
1074 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
1076 size_t string_length
;
1078 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
1079 test_compare(MEMCACHED_NOTFOUND
, rc
);
1080 test_zero(string_length
);
1082 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
1083 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1084 test_zero(string_length
);
1088 /* Make sure zero length keys are marked as bad */
1090 test_compare(MEMCACHED_SUCCESS
,
1091 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1092 size_t string_length
;
1093 char *string
= memcached_get(memc_clone
, key
, 0,
1094 &string_length
, &flags
, &rc
);
1095 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1096 test_zero(string_length
);
1100 memcached_free(memc_clone
);
1102 return TEST_SUCCESS
;
1105 #define READ_THROUGH_VALUE "set for me"
1106 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
1109 memcached_result_st
*result
)
1111 (void)memc
;(void)key
;(void)key_length
;
1112 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
1115 #ifndef __INTEL_COMPILER
1116 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1119 test_return_t
read_through(memcached_st
*memc
)
1121 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1123 size_t string_length
;
1125 memcached_return_t rc
;
1126 char *string
= memcached_get(memc
,
1127 test_literal_param(__func__
),
1128 &string_length
, &flags
, &rc
);
1130 test_compare(MEMCACHED_NOTFOUND
, rc
);
1131 test_false(string_length
);
1134 test_compare(MEMCACHED_SUCCESS
,
1135 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1137 string
= memcached_get(memc
,
1138 test_literal_param(__func__
),
1139 &string_length
, &flags
, &rc
);
1141 test_compare(MEMCACHED_SUCCESS
, rc
);
1142 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1143 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1144 test_strcmp(READ_THROUGH_VALUE
, string
);
1147 string
= memcached_get(memc
,
1148 test_literal_param(__func__
),
1149 &string_length
, &flags
, &rc
);
1151 test_compare(MEMCACHED_SUCCESS
, rc
);
1153 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1154 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1155 test_strcmp(READ_THROUGH_VALUE
, string
);
1158 return TEST_SUCCESS
;
1161 test_return_t
get_test(memcached_st
*memc
)
1163 memcached_return_t rc
;
1165 size_t string_length
;
1168 uint64_t query_id
= memcached_query_id(memc
);
1169 rc
= memcached_delete(memc
,
1170 test_literal_param(__func__
),
1172 test_true_got(rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_NOTFOUND
, memcached_last_error_message(memc
));
1173 test_compare(query_id
+1, memcached_query_id(memc
));
1175 string
= memcached_get(memc
,
1176 test_literal_param(__func__
),
1177 &string_length
, &flags
, &rc
);
1179 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1180 test_false(string_length
);
1183 return TEST_SUCCESS
;
1186 test_return_t
get_test2(memcached_st
*memc
)
1188 const char *value
= "when we sanitize";
1190 uint64_t query_id
= memcached_query_id(memc
);
1191 test_compare(return_value_based_on_buffering(memc
),
1193 test_literal_param(__func__
),
1194 value
, strlen(value
),
1195 time_t(0), uint32_t(0)));
1196 test_compare(query_id
+1, memcached_query_id(memc
));
1198 query_id
= memcached_query_id(memc
);
1199 test_true(query_id
);
1202 size_t string_length
;
1203 memcached_return_t rc
;
1204 char *string
= memcached_get(memc
,
1205 test_literal_param(__func__
),
1206 &string_length
, &flags
, &rc
);
1207 test_compare(query_id
+1, memcached_query_id(memc
));
1209 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1210 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1212 test_compare(strlen(value
), string_length
);
1213 test_memcmp(string
, value
, string_length
);
1217 return TEST_SUCCESS
;
1220 test_return_t
set_test2(memcached_st
*memc
)
1222 for (uint32_t x
= 0; x
< 10; x
++)
1224 test_compare(return_value_based_on_buffering(memc
),
1226 test_literal_param("foo"),
1227 test_literal_param("train in the brain"),
1228 time_t(0), uint32_t(0)));
1231 return TEST_SUCCESS
;
1234 test_return_t
set_test3(memcached_st
*memc
)
1236 size_t value_length
= 8191;
1238 libtest::vchar_t value
;
1239 value
.reserve(value_length
);
1240 for (uint32_t x
= 0; x
< value_length
; x
++)
1242 value
.push_back(char(x
% 127));
1245 /* The dump test relies on there being at least 32 items in memcached */
1246 for (uint32_t x
= 0; x
< 32; x
++)
1250 snprintf(key
, sizeof(key
), "foo%u", x
);
1252 uint64_t query_id
= memcached_query_id(memc
);
1253 test_compare_hint(return_value_based_on_buffering(memc
),
1254 memcached_set(memc
, key
, strlen(key
),
1255 &value
[0], value
.size(),
1256 time_t(0), uint32_t(0)),
1257 memcached_last_error_message(memc
));
1258 test_compare(query_id
+1, memcached_query_id(memc
));
1261 return TEST_SUCCESS
;
1264 test_return_t
get_test3(memcached_st
*memc
)
1266 size_t value_length
= 8191;
1268 libtest::vchar_t value
;
1269 value
.reserve(value_length
);
1270 for (uint32_t x
= 0; x
< value_length
; x
++)
1272 value
.push_back(char(x
% 127));
1275 test_compare_hint(return_value_based_on_buffering(memc
),
1277 test_literal_param(__func__
),
1278 &value
[0], value
.size(),
1279 time_t(0), uint32_t(0)),
1280 memcached_last_error_message(memc
));
1282 size_t string_length
;
1284 memcached_return_t rc
;
1285 char *string
= memcached_get(memc
,
1286 test_literal_param(__func__
),
1287 &string_length
, &flags
, &rc
);
1289 test_compare(MEMCACHED_SUCCESS
, rc
);
1291 test_compare(value
.size(), string_length
);
1292 test_memcmp(string
, &value
[0], string_length
);
1296 return TEST_SUCCESS
;
1299 test_return_t
get_test4(memcached_st
*memc
)
1301 size_t value_length
= 8191;
1303 libtest::vchar_t value
;
1304 value
.reserve(value_length
);
1305 for (uint32_t x
= 0; x
< value_length
; x
++)
1307 value
.push_back(char(x
% 127));
1310 test_compare_hint(return_value_based_on_buffering(memc
),
1312 test_literal_param(__func__
),
1313 &value
[0], value
.size(),
1314 time_t(0), uint32_t(0)),
1315 memcached_last_error_message(memc
));
1317 for (uint32_t x
= 0; x
< 10; x
++)
1320 size_t string_length
;
1321 memcached_return_t rc
;
1322 char *string
= memcached_get(memc
,
1323 test_literal_param(__func__
),
1324 &string_length
, &flags
, &rc
);
1326 test_compare(MEMCACHED_SUCCESS
, rc
);
1328 test_compare(value
.size(), string_length
);
1329 test_memcmp(string
, &value
[0], string_length
);
1333 return TEST_SUCCESS
;
1337 * This test verifies that memcached_read_one_response doesn't try to
1338 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1339 * responses before you execute a storage command.
1341 test_return_t
get_test5(memcached_st
*memc
)
1344 ** Request the same key twice, to ensure that we hash to the same server
1345 ** (so that we have multiple response values queued up) ;-)
1347 const char *keys
[]= { "key", "key" };
1348 size_t lengths
[]= { 3, 3 };
1352 test_compare_hint(return_value_based_on_buffering(memc
),
1353 memcached_set(memc
, keys
[0], lengths
[0],
1354 keys
[0], lengths
[0],
1355 time_t(0), uint32_t(0)),
1356 memcached_last_error_message(memc
));
1357 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1359 memcached_result_st results_obj
;
1360 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1363 memcached_return_t rc
;
1364 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1367 memcached_result_free(&results_obj
);
1369 /* Don't read out the second result, but issue a set instead.. */
1370 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1372 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1373 &rlen
, &flags
, &rc
);
1375 test_compare(MEMCACHED_NOTFOUND
, rc
);
1376 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1378 test_compare(MEMCACHED_SUCCESS
, rc
);
1381 return TEST_SUCCESS
;
1384 test_return_t
mget_end(memcached_st
*memc
)
1386 const char *keys
[]= { "foo", "foo2" };
1387 size_t lengths
[]= { 3, 4 };
1388 const char *values
[]= { "fjord", "41" };
1391 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1393 test_compare(MEMCACHED_SUCCESS
,
1395 keys
[x
], lengths
[x
],
1396 values
[x
], strlen(values
[x
]),
1397 time_t(0), uint32_t(0)));
1401 size_t string_length
;
1404 // retrieve both via mget
1405 test_compare(MEMCACHED_SUCCESS
,
1406 memcached_mget(memc
,
1408 test_array_length(keys
)));
1410 char key
[MEMCACHED_MAX_KEY
];
1412 memcached_return_t rc
;
1414 // this should get both
1415 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1417 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1419 test_compare(MEMCACHED_SUCCESS
, rc
);
1421 if (key_length
== 4)
1426 test_compare(string_length
, strlen(values
[val
]));
1427 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1431 // this should indicate end
1432 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1433 test_compare(MEMCACHED_END
, rc
);
1437 test_compare(MEMCACHED_SUCCESS
,
1438 memcached_mget(memc
, keys
, lengths
, 1));
1440 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1441 test_compare(key_length
, lengths
[0]);
1442 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1443 test_compare(string_length
, strlen(values
[0]));
1444 test_true(strncmp(values
[0], string
, string_length
) == 0);
1445 test_compare(MEMCACHED_SUCCESS
, rc
);
1448 // this should indicate end
1449 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1450 test_compare(MEMCACHED_END
, rc
);
1453 return TEST_SUCCESS
;
1456 /* Do not copy the style of this code, I just access hosts to testthis function */
1457 test_return_t
stats_servername_test(memcached_st
*memc
)
1459 memcached_stat_st memc_stat
;
1460 memcached_server_instance_st instance
=
1461 memcached_server_instance_by_position(memc
, 0);
1463 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1465 return TEST_SKIPPED
;
1468 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1469 memcached_server_name(instance
),
1470 memcached_server_port(instance
)));
1472 return TEST_SUCCESS
;
1475 test_return_t
increment_test(memcached_st
*memc
)
1477 uint64_t new_number
;
1479 test_compare(MEMCACHED_SUCCESS
,
1481 test_literal_param("number"),
1482 test_literal_param("0"),
1483 (time_t)0, (uint32_t)0));
1485 test_compare(MEMCACHED_SUCCESS
,
1486 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1487 test_compare(uint64_t(1), new_number
);
1489 test_compare(MEMCACHED_SUCCESS
,
1490 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1491 test_compare(uint64_t(2), new_number
);
1493 return TEST_SUCCESS
;
1496 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1498 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1500 uint64_t new_number
;
1501 uint64_t initial
= 0;
1503 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1505 test_compare(MEMCACHED_SUCCESS
,
1506 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1507 test_compare(new_number
, initial
);
1509 test_compare(MEMCACHED_SUCCESS
,
1510 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1511 test_compare(new_number
, (initial
+1));
1513 return TEST_SUCCESS
;
1516 test_return_t
decrement_test(memcached_st
*memc
)
1518 test_compare(return_value_based_on_buffering(memc
),
1520 test_literal_param(__func__
),
1521 test_literal_param("3"),
1522 time_t(0), uint32_t(0)));
1523 // Make sure we flush the value we just set
1524 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1526 uint64_t new_number
;
1527 test_compare(MEMCACHED_SUCCESS
,
1528 memcached_decrement(memc
,
1529 test_literal_param(__func__
),
1531 test_compare(uint64_t(2), new_number
);
1533 test_compare(MEMCACHED_SUCCESS
,
1534 memcached_decrement(memc
,
1535 test_literal_param(__func__
),
1537 test_compare(uint64_t(1), new_number
);
1539 return TEST_SUCCESS
;
1542 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1544 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1546 uint64_t initial
= 3;
1548 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1550 uint64_t new_number
;
1551 test_compare(MEMCACHED_SUCCESS
,
1552 memcached_decrement_with_initial(memc
,
1553 test_literal_param(__func__
),
1556 test_compare(new_number
, initial
);
1558 test_compare(MEMCACHED_SUCCESS
,
1559 memcached_decrement_with_initial(memc
,
1560 test_literal_param(__func__
),
1563 test_compare(new_number
, (initial
- 1));
1565 return TEST_SUCCESS
;
1568 test_return_t
increment_by_key_test(memcached_st
*memc
)
1570 const char *master_key
= "foo";
1571 const char *key
= "number";
1572 const char *value
= "0";
1574 test_compare(return_value_based_on_buffering(memc
),
1575 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1577 value
, strlen(value
),
1578 time_t(0), uint32_t(0)));
1580 // Make sure we flush the value we just set
1581 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1583 uint64_t new_number
;
1584 test_compare(MEMCACHED_SUCCESS
,
1585 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1586 key
, strlen(key
), 1, &new_number
));
1587 test_compare(uint64_t(1), new_number
);
1589 test_compare(MEMCACHED_SUCCESS
,
1590 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1591 key
, strlen(key
), 1, &new_number
));
1592 test_compare(uint64_t(2), new_number
);
1594 return TEST_SUCCESS
;
1597 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1599 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1601 uint64_t new_number
;
1602 const char *master_key
= "foo";
1603 const char *key
= "number";
1604 uint64_t initial
= 0;
1606 test_compare(MEMCACHED_SUCCESS
,
1607 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1609 1, initial
, 0, &new_number
));
1610 test_compare(new_number
, initial
);
1612 test_compare(MEMCACHED_SUCCESS
,
1613 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1615 1, initial
, 0, &new_number
));
1616 test_compare(new_number
, (initial
+1));
1618 return TEST_SUCCESS
;
1621 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1623 uint64_t new_number
;
1624 const char *value
= "3";
1626 test_compare(return_value_based_on_buffering(memc
),
1627 memcached_set_by_key(memc
,
1628 test_literal_param("foo"),
1629 test_literal_param("number"),
1630 value
, strlen(value
),
1631 (time_t)0, (uint32_t)0));
1633 test_compare(MEMCACHED_SUCCESS
,
1634 memcached_decrement_by_key(memc
,
1635 test_literal_param("foo"),
1636 test_literal_param("number"),
1638 test_compare(uint64_t(2), new_number
);
1640 test_compare(MEMCACHED_SUCCESS
,
1641 memcached_decrement_by_key(memc
,
1642 test_literal_param("foo"),
1643 test_literal_param("number"),
1645 test_compare(uint64_t(1), new_number
);
1647 return TEST_SUCCESS
;
1650 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1652 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1654 uint64_t new_number
;
1655 uint64_t initial
= 3;
1657 test_compare(MEMCACHED_SUCCESS
,
1658 memcached_decrement_with_initial_by_key(memc
,
1659 test_literal_param("foo"),
1660 test_literal_param("number"),
1661 1, initial
, 0, &new_number
));
1662 test_compare(new_number
, initial
);
1664 test_compare(MEMCACHED_SUCCESS
,
1665 memcached_decrement_with_initial_by_key(memc
,
1666 test_literal_param("foo"),
1667 test_literal_param("number"),
1668 1, initial
, 0, &new_number
));
1669 test_compare(new_number
, (initial
- 1));
1671 return TEST_SUCCESS
;
1673 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1675 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1677 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1679 test_compare(return_value_based_on_buffering(memc
),
1681 test_literal_param("number"),
1682 test_literal_param("0"),
1683 (time_t)0, (uint32_t)0));
1685 uint64_t new_number
;
1686 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1687 test_literal_param("number"),
1689 test_compare(uint64_t(1), new_number
);
1691 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1692 test_literal_param("number"),
1694 test_compare(uint64_t(2), new_number
);
1696 return TEST_SUCCESS
;
1699 test_return_t
quit_test(memcached_st
*memc
)
1701 const char *value
= "sanford and sun";
1703 test_compare(return_value_based_on_buffering(memc
),
1705 test_literal_param(__func__
),
1706 value
, strlen(value
),
1707 (time_t)10, (uint32_t)3));
1708 memcached_quit(memc
);
1710 test_compare(return_value_based_on_buffering(memc
),
1712 test_literal_param(__func__
),
1713 value
, strlen(value
),
1714 (time_t)50, (uint32_t)9));
1716 return TEST_SUCCESS
;
1719 test_return_t
mget_result_test(memcached_st
*memc
)
1721 const char *keys
[]= {"fudge", "son", "food"};
1722 size_t key_length
[]= {5, 3, 4};
1724 memcached_result_st results_obj
;
1725 memcached_result_st
*results
;
1727 results
= memcached_result_create(memc
, &results_obj
);
1729 test_true(&results_obj
== results
);
1731 /* We need to empty the server before continueing test */
1732 test_compare(MEMCACHED_SUCCESS
,
1733 memcached_flush(memc
, 0));
1735 test_compare(MEMCACHED_SUCCESS
,
1736 memcached_mget(memc
, keys
, key_length
, 3));
1738 memcached_return_t rc
;
1739 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1744 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1745 test_false(results
);
1746 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1748 for (uint32_t x
= 0; x
< 3; x
++)
1750 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1751 keys
[x
], key_length
[x
],
1752 (time_t)50, (uint32_t)9);
1753 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1756 test_compare(MEMCACHED_SUCCESS
,
1757 memcached_mget(memc
, keys
, key_length
, 3));
1759 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1762 test_true(&results_obj
== results
);
1763 test_compare(MEMCACHED_SUCCESS
, rc
);
1764 test_memcmp(memcached_result_key_value(results
),
1765 memcached_result_value(results
),
1766 memcached_result_length(results
));
1767 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1770 memcached_result_free(&results_obj
);
1772 return TEST_SUCCESS
;
1775 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1777 const char *keys
[]= {"fudge", "son", "food"};
1778 size_t key_length
[]= {5, 3, 4};
1780 memcached_result_st
*results
;
1782 /* We need to empty the server before continueing test */
1783 test_compare(MEMCACHED_SUCCESS
,
1784 memcached_flush(memc
, 0));
1786 test_compare(MEMCACHED_SUCCESS
,
1787 memcached_mget(memc
, keys
, key_length
, 3));
1789 memcached_return_t rc
;
1790 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1794 test_false(results
);
1795 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1797 for (uint32_t x
= 0; x
< 3; x
++)
1799 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1800 keys
[x
], key_length
[x
],
1801 (time_t)50, (uint32_t)9);
1802 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1805 test_compare(MEMCACHED_SUCCESS
,
1806 memcached_mget(memc
, keys
, key_length
, 3));
1809 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1812 test_compare(MEMCACHED_SUCCESS
, rc
);
1813 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1814 test_memcmp(memcached_result_key_value(results
),
1815 memcached_result_value(results
),
1816 memcached_result_length(results
));
1817 memcached_result_free(results
);
1821 return TEST_SUCCESS
;
1824 test_return_t
mget_result_function(memcached_st
*memc
)
1826 const char *keys
[]= {"fudge", "son", "food"};
1827 size_t key_length
[]= {5, 3, 4};
1829 memcached_execute_fn callbacks
[1];
1831 for (uint32_t x
= 0; x
< 3; x
++)
1833 test_compare(return_value_based_on_buffering(memc
),
1834 memcached_set(memc
, keys
[x
], key_length
[x
],
1835 keys
[x
], key_length
[x
],
1836 time_t(50), uint32_t(9)));
1838 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1839 memcached_quit(memc
);
1841 test_compare(MEMCACHED_SUCCESS
,
1842 memcached_mget(memc
, keys
, key_length
, 3));
1844 callbacks
[0]= &callback_counter
;
1847 test_compare(MEMCACHED_SUCCESS
,
1848 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1850 test_compare(size_t(3), counter
);
1852 return TEST_SUCCESS
;
1855 test_return_t
mget_test(memcached_st
*memc
)
1857 const char *keys
[]= {"fudge", "son", "food"};
1858 size_t key_length
[]= {5, 3, 4};
1860 char return_key
[MEMCACHED_MAX_KEY
];
1861 size_t return_key_length
;
1863 size_t return_value_length
;
1865 test_compare(MEMCACHED_SUCCESS
,
1866 memcached_mget(memc
, keys
, key_length
, 3));
1869 memcached_return_t rc
;
1870 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1871 &return_value_length
, &flags
, &rc
)))
1873 test_true(return_value
);
1875 test_false(return_value
);
1876 test_zero(return_value_length
);
1877 test_compare(MEMCACHED_NOTFOUND
, rc
);
1879 for (uint32_t x
= 0; x
< 3; x
++)
1881 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1882 keys
[x
], key_length
[x
],
1883 (time_t)50, (uint32_t)9);
1884 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1886 test_compare(MEMCACHED_SUCCESS
,
1887 memcached_mget(memc
, keys
, key_length
, 3));
1890 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1891 &return_value_length
, &flags
, &rc
)))
1893 test_true(return_value
);
1894 test_compare(MEMCACHED_SUCCESS
, rc
);
1895 if (not memc
->_namespace
)
1897 test_compare(return_key_length
, return_value_length
);
1898 test_memcmp(return_value
, return_key
, return_value_length
);
1904 return TEST_SUCCESS
;
1907 test_return_t
mget_execute(memcached_st
*original_memc
)
1909 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1911 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1914 keys_st
keys(20480);
1916 /* First add all of the items.. */
1917 char blob
[1024] = {0};
1919 for (size_t x
= 0; x
< keys
.size(); ++x
)
1921 uint64_t query_id
= memcached_query_id(memc
);
1922 memcached_return_t rc
= memcached_add(memc
,
1923 keys
.key_at(x
), keys
.length_at(x
),
1926 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
,
1927 memcached_strerror(NULL
, rc
));
1928 test_compare(query_id
+1, memcached_query_id(memc
));
1931 /* Try to get all of them with a large multiget */
1933 memcached_execute_fn callbacks
[]= { &callback_counter
};
1934 test_compare(MEMCACHED_SUCCESS
,
1935 memcached_mget_execute(memc
,
1936 keys
.keys_ptr(), keys
.lengths_ptr(),
1937 keys
.size(), callbacks
, &counter
, 1));
1940 uint64_t query_id
= memcached_query_id(memc
);
1941 test_compare(MEMCACHED_SUCCESS
,
1942 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1943 test_compare(query_id
, memcached_query_id(memc
));
1945 /* Verify that we got all of the items */
1946 test_compare(keys
.size(), counter
);
1949 memcached_free(memc
);
1951 return TEST_SUCCESS
;
1954 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1955 static pairs_st
*global_pairs
;
1957 test_return_t
key_setup(memcached_st
*memc
)
1959 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1961 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1963 return TEST_SUCCESS
;
1966 test_return_t
key_teardown(memcached_st
*)
1968 pairs_free(global_pairs
);
1970 return TEST_SUCCESS
;
1973 test_return_t
block_add_regression(memcached_st
*memc
)
1975 /* First add all of the items.. */
1976 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1978 char blob
[1024] = {0};
1980 memcached_return_t rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1981 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
, memcached_strerror(NULL
, rc
));
1984 return TEST_SUCCESS
;
1987 test_return_t
binary_add_regression(memcached_st
*memc
)
1989 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1990 test_return_t rc
= block_add_regression(memc
);
1995 test_return_t
get_stats_keys(memcached_st
*memc
)
1999 memcached_stat_st memc_stat
;
2000 memcached_return_t rc
;
2002 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
2003 test_compare(MEMCACHED_SUCCESS
, rc
);
2004 for (ptr
= stat_list
; *ptr
; ptr
++)
2009 return TEST_SUCCESS
;
2012 test_return_t
version_string_test(memcached_st
*)
2014 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
2016 return TEST_SUCCESS
;
2019 test_return_t
get_stats(memcached_st
*memc
)
2021 memcached_return_t rc
;
2023 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
2024 test_compare(MEMCACHED_SUCCESS
, rc
);
2025 test_true(memc_stat
);
2027 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
2029 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
2030 test_compare(MEMCACHED_SUCCESS
, rc
);
2031 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
2036 memcached_stat_free(NULL
, memc_stat
);
2038 return TEST_SUCCESS
;
2041 test_return_t
add_host_test(memcached_st
*memc
)
2043 char servername
[]= "0.example.com";
2045 memcached_return_t rc
;
2046 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2047 test_compare(1U, memcached_server_list_count(servers
));
2049 for (unsigned int x
= 2; x
< 20; x
++)
2051 char buffer
[SMALL_STRING_LEN
];
2053 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2054 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2056 test_compare(MEMCACHED_SUCCESS
, rc
);
2057 test_compare(x
, memcached_server_list_count(servers
));
2060 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2061 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2063 memcached_server_list_free(servers
);
2065 return TEST_SUCCESS
;
2068 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
2070 memcached_return_t rc
;
2072 const char *key
= "not_found";
2073 size_t key_length
= test_literal_param_size("not_found");
2075 test_compare(MEMCACHED_SUCCESS
,
2076 memcached_mget(memc
, &key
, &key_length
, 1));
2078 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
2080 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2082 memcached_result_free(result
);
2084 return TEST_SUCCESS
;
2087 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
2089 return MEMCACHED_SUCCESS
;
2092 static memcached_return_t
cleanup_test_callback(memcached_st
*)
2094 return MEMCACHED_SUCCESS
;
2097 test_return_t
callback_test(memcached_st
*memc
)
2099 /* Test User Data */
2103 memcached_return_t rc
;
2105 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
2106 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
2107 test_true(*test_ptr
== x
);
2110 /* Test Clone Callback */
2112 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2113 void *clone_cb_ptr
= *(void **)&clone_cb
;
2114 void *temp_function
= NULL
;
2116 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
2117 memcached_return_t rc
;
2118 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2119 test_true(temp_function
== clone_cb_ptr
);
2120 test_compare(MEMCACHED_SUCCESS
, rc
);
2123 /* Test Cleanup Callback */
2125 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2126 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2127 void *temp_function
= NULL
;
2128 memcached_return_t rc
;
2130 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2131 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2132 test_true(temp_function
== cleanup_cb_ptr
);
2135 return TEST_SUCCESS
;
2138 /* We don't test the behavior itself, we test the switches */
2139 test_return_t
behavior_test(memcached_st
*memc
)
2141 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2142 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2144 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2145 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2147 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2148 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2150 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2151 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2153 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2154 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2156 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2157 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2159 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2160 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2162 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2164 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2166 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2167 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2168 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2170 return TEST_SUCCESS
;
2173 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2175 test_compare(MEMCACHED_DEPRECATED
,
2176 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2178 // Platform dependent
2180 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2184 return TEST_SUCCESS
;
2188 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2190 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2191 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2193 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2195 if (memcached_success(rc
))
2204 return TEST_SUCCESS
;
2208 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2210 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2211 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2213 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2215 if (memcached_success(rc
))
2224 return TEST_SUCCESS
;
2227 /* Make sure we behave properly if server list has no values */
2228 test_return_t
user_supplied_bug4(memcached_st
*memc
)
2230 const char *keys
[]= {"fudge", "son", "food"};
2231 size_t key_length
[]= {5, 3, 4};
2233 /* Here we free everything before running a bunch of mget tests */
2234 memcached_servers_reset(memc
);
2237 /* We need to empty the server before continueing test */
2238 test_compare(MEMCACHED_NO_SERVERS
,
2239 memcached_flush(memc
, 0));
2241 test_compare(MEMCACHED_NO_SERVERS
,
2242 memcached_mget(memc
, keys
, key_length
, 3));
2245 unsigned int keys_returned
;
2246 memcached_return_t rc
;
2247 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2248 test_compare(MEMCACHED_NOTFOUND
, rc
);
2249 test_zero(keys_returned
);
2252 for (uint32_t x
= 0; x
< 3; x
++)
2254 test_compare(MEMCACHED_NO_SERVERS
,
2255 memcached_set(memc
, keys
[x
], key_length
[x
],
2256 keys
[x
], key_length
[x
],
2257 (time_t)50, (uint32_t)9));
2260 test_compare(MEMCACHED_NO_SERVERS
,
2261 memcached_mget(memc
, keys
, key_length
, 3));
2265 char return_key
[MEMCACHED_MAX_KEY
];
2266 memcached_return_t rc
;
2267 size_t return_key_length
;
2268 size_t return_value_length
;
2271 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2272 &return_value_length
, &flags
, &rc
)))
2274 test_true(return_value
);
2275 test_compare(MEMCACHED_SUCCESS
, rc
);
2276 test_true(return_key_length
== return_value_length
);
2277 test_memcmp(return_value
, return_key
, return_value_length
);
2283 return TEST_SUCCESS
;
2286 #define VALUE_SIZE_BUG5 1048064
2287 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2289 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2290 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2292 size_t value_length
;
2294 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2296 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2298 insert_data
[x
]= (signed char)rand();
2301 test_compare(MEMCACHED_SUCCESS
,
2302 memcached_flush(memc
, 0));
2304 memcached_return_t rc
;
2305 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2306 test_compare(MEMCACHED_SUCCESS
,
2307 memcached_mget(memc
, keys
, key_length
, 4));
2310 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2311 test_compare(MEMCACHED_NOTFOUND
, rc
);
2314 for (uint32_t x
= 0; x
< 4; x
++)
2316 test_compare(MEMCACHED_SUCCESS
,
2317 memcached_set(memc
, keys
[x
], key_length
[x
],
2318 insert_data
, VALUE_SIZE_BUG5
,
2319 (time_t)0, (uint32_t)0));
2322 for (uint32_t x
= 0; x
< 10; x
++)
2324 value
= memcached_get(memc
, keys
[0], key_length
[0],
2325 &value_length
, &flags
, &rc
);
2326 test_compare(rc
, MEMCACHED_SUCCESS
);
2330 test_compare(MEMCACHED_SUCCESS
,
2331 memcached_mget(memc
, keys
, key_length
, 4));
2333 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2334 test_compare(4U, count
);
2336 delete [] insert_data
;
2338 return TEST_SUCCESS
;
2341 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2343 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2344 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2345 char return_key
[MEMCACHED_MAX_KEY
];
2346 size_t return_key_length
;
2348 size_t value_length
;
2350 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2352 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2354 insert_data
[x
]= (signed char)rand();
2357 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2359 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2361 // We will now confirm that memcached_mget() returns success, but we will
2362 // then check to make sure that no actual keys are returned.
2363 test_compare(MEMCACHED_SUCCESS
,
2364 memcached_mget(memc
, keys
, key_length
, 4));
2366 memcached_return_t rc
;
2368 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2369 &value_length
, &flags
, &rc
)))
2374 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2376 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2378 test_compare(MEMCACHED_SUCCESS
,
2379 memcached_set(memc
, keys
[x
], key_length
[x
],
2380 insert_data
, VALUE_SIZE_BUG5
,
2381 (time_t)0, (uint32_t)0));
2383 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2385 for (uint32_t x
= 0; x
< 2; x
++)
2387 value
= memcached_get(memc
, keys
[0], key_length
[0],
2388 &value_length
, &flags
, &rc
);
2392 test_compare(MEMCACHED_SUCCESS
,
2393 memcached_mget(memc
, keys
, key_length
, 4));
2394 /* We test for purge of partial complete fetches */
2395 for (count
= 3; count
; count
--)
2397 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2398 &value_length
, &flags
, &rc
);
2399 test_compare(MEMCACHED_SUCCESS
, rc
);
2400 test_memcmp(value
, insert_data
, value_length
);
2401 test_true(value_length
);
2405 delete [] insert_data
;
2407 return TEST_SUCCESS
;
2410 test_return_t
user_supplied_bug8(memcached_st
*)
2412 memcached_return_t rc
;
2414 memcached_st
*memc_clone
;
2416 memcached_server_st
*servers
;
2417 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";
2419 servers
= memcached_servers_parse(server_list
);
2422 mine
= memcached_create(NULL
);
2423 rc
= memcached_server_push(mine
, servers
);
2424 test_compare(MEMCACHED_SUCCESS
, rc
);
2425 memcached_server_list_free(servers
);
2428 memc_clone
= memcached_clone(NULL
, mine
);
2430 memcached_quit(mine
);
2431 memcached_quit(memc_clone
);
2434 memcached_free(mine
);
2435 memcached_free(memc_clone
);
2437 return TEST_SUCCESS
;
2440 /* Test flag store/retrieve */
2441 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2443 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2444 test_true(insert_data
);
2446 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2448 insert_data
[x
]= (signed char)rand();
2451 memcached_flush(memc
, 0);
2453 const char *keys
= "036790384900";
2454 size_t key_length
= strlen(keys
);
2455 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2456 insert_data
, VALUE_SIZE_BUG5
,
2458 memcached_last_error_message(memc
));
2460 memcached_return_t rc
;
2461 size_t value_length
;
2463 char *value
= memcached_get(memc
, keys
, key_length
,
2464 &value_length
, &flags
, &rc
);
2465 test_compare(245U, flags
);
2469 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2471 char return_key
[MEMCACHED_MAX_KEY
];
2472 size_t return_key_length
;
2474 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2475 &value_length
, &flags
, &rc
);
2476 test_compare(uint32_t(245), flags
);
2479 delete [] insert_data
;
2482 return TEST_SUCCESS
;
2485 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2487 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2488 size_t key_length
[3];
2492 char return_key
[MEMCACHED_MAX_KEY
];
2493 size_t return_key_length
;
2495 size_t return_value_length
;
2498 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2499 key_length
[1]= strlen("fudge&*@#");
2500 key_length
[2]= strlen("for^#@&$not");
2503 for (unsigned int x
= 0; x
< 3; x
++)
2505 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2506 keys
[x
], key_length
[x
],
2507 (time_t)50, (uint32_t)9);
2508 test_compare(MEMCACHED_SUCCESS
, rc
);
2511 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2512 test_compare(MEMCACHED_SUCCESS
, rc
);
2514 /* We need to empty the server before continueing test */
2515 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2516 &return_value_length
, &flags
, &rc
)) != NULL
)
2518 test_true(return_value
);
2522 test_compare(3U, count
);
2524 return TEST_SUCCESS
;
2527 /* We are testing with aggressive timeout to get failures */
2528 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2530 size_t value_length
= 512;
2531 unsigned int set
= 1;
2532 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2534 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2535 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2536 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2538 libtest::vchar_t value
;
2539 value
.reserve(value_length
);
2540 for (uint32_t x
= 0; x
< value_length
; x
++)
2542 value
.push_back(char(x
% 127));
2545 for (unsigned int x
= 1; x
<= 100000; ++x
)
2547 memcached_return_t rc
= memcached_set(mclone
,
2548 test_literal_param("foo"),
2549 &value
[0], value
.size(),
2552 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2553 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2554 memcached_strerror(NULL
, rc
));
2556 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2562 memcached_free(mclone
);
2564 return TEST_SUCCESS
;
2568 We are looking failures in the async protocol
2570 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2572 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2574 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2575 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2576 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2578 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2581 libtest::vchar_t value
;
2583 for (unsigned int x
= 0; x
< 512; x
++)
2585 value
.push_back(char(x
% 127));
2588 for (unsigned int x
= 1; x
<= 100000; ++x
)
2590 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2594 memcached_free(mclone
);
2596 return TEST_SUCCESS
;
2600 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2602 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2604 memcached_return_t rc
;
2606 size_t value_length
;
2608 uint64_t number_value
;
2610 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2611 &value_length
, &flags
, &rc
);
2613 test_compare(MEMCACHED_NOTFOUND
, rc
);
2615 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2618 /* The binary protocol will set the key if it doesn't exist */
2619 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2621 test_compare(MEMCACHED_SUCCESS
, rc
);
2625 test_compare(MEMCACHED_NOTFOUND
, rc
);
2628 test_compare(MEMCACHED_SUCCESS
,
2629 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2631 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2635 test_compare(MEMCACHED_SUCCESS
,
2636 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2637 test_compare(2UL, number_value
);
2639 return TEST_SUCCESS
;
2643 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2644 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2646 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2648 char key
[] = "key34567890";
2650 char commandFirst
[]= "set key34567890 0 0 ";
2651 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2652 size_t commandLength
;
2654 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2656 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2658 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2660 char *overflow
= new (std::nothrow
) char[testSize
];
2661 test_true(overflow
);
2663 memset(overflow
, 'x', testSize
);
2664 test_compare(MEMCACHED_SUCCESS
,
2665 memcached_set(memc
, key
, strlen(key
),
2666 overflow
, testSize
, 0, 0));
2670 return TEST_SUCCESS
;
2675 Test values of many different sizes
2676 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2677 set key34567890 0 0 8169 \r\n
2678 is sent followed by buffer of size 8169, followed by 8169
2680 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2682 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2684 libtest::vchar_t value
;
2685 value
.reserve(18000);
2686 for (size_t x
= 0; x
< 18000; x
++)
2688 value
.push_back((char) (x
% 127));
2691 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2693 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2694 &value
[0], current_length
,
2695 (time_t)0, (uint32_t)0);
2696 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2698 size_t string_length
;
2700 char *string
= memcached_get(memc
, test_literal_param("foo"),
2701 &string_length
, &flags
, &rc
);
2703 test_compare(MEMCACHED_SUCCESS
, rc
);
2704 test_compare(string_length
, current_length
);
2705 test_memcmp(string
, &value
[0], string_length
);
2710 return TEST_SUCCESS
;
2714 Look for zero length value problems
2716 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2718 for (uint32_t x
= 0; x
< 2; x
++)
2720 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2722 (time_t)0, (uint32_t)0);
2724 test_compare(MEMCACHED_SUCCESS
, rc
);
2728 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2729 &length
, &flags
, &rc
);
2731 test_compare(MEMCACHED_SUCCESS
, rc
);
2736 value
= memcached_get(memc
, test_literal_param("mykey"),
2737 &length
, &flags
, &rc
);
2739 test_compare(MEMCACHED_SUCCESS
, rc
);
2745 return TEST_SUCCESS
;
2748 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2749 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2751 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2753 (time_t)0, UINT32_MAX
),
2754 memcached_last_error_message(memc
));
2759 memcached_return_t rc
;
2760 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2761 &length
, &flags
, &rc
);
2763 test_compare(MEMCACHED_SUCCESS
, rc
);
2766 test_compare(flags
, UINT32_MAX
);
2768 return TEST_SUCCESS
;
2771 #if !defined(__sun) && !defined(__OpenBSD__)
2772 /* Check the validity of chinese key*/
2773 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2775 const char *key
= "豆瓣";
2776 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2777 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2778 value
, strlen(value
),
2781 test_compare(MEMCACHED_SUCCESS
, rc
);
2785 char *value2
= memcached_get(memc
, key
, strlen(key
),
2786 &length
, &flags
, &rc
);
2788 test_true(length
==strlen(value
));
2789 test_compare(MEMCACHED_SUCCESS
, rc
);
2790 test_memcmp(value
, value2
, length
);
2793 return TEST_SUCCESS
;
2801 test_return_t
user_supplied_bug19(memcached_st
*)
2803 memcached_return_t res
;
2805 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2807 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2810 memcached_free(memc
);
2812 return TEST_SUCCESS
;
2815 /* CAS test from Andei */
2816 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2818 const char *key
= "abc";
2819 size_t key_len
= strlen("abc");
2821 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2823 test_compare(MEMCACHED_SUCCESS
,
2825 test_literal_param("abc"),
2826 test_literal_param("foobar"),
2827 (time_t)0, (uint32_t)0));
2829 test_compare(MEMCACHED_SUCCESS
,
2830 memcached_mget(memc
, &key
, &key_len
, 1));
2832 memcached_result_st result_obj
;
2833 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2836 memcached_result_create(memc
, &result_obj
);
2837 memcached_return_t status
;
2838 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2841 test_compare(MEMCACHED_SUCCESS
, status
);
2843 memcached_result_free(result
);
2845 return TEST_SUCCESS
;
2848 /* Large mget() of missing keys with binary proto
2850 * If many binary quiet commands (such as getq's in an mget) fill the output
2851 * buffer and the server chooses not to respond, memcached_flush hangs. See
2852 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2855 /* sighandler_t function that always asserts false */
2856 static void fail(int)
2862 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2867 return TEST_SKIPPED
;
2869 void (*oldalarm
)(int);
2871 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2872 test_true(memc_clone
);
2874 /* only binproto uses getq for mget */
2875 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2877 /* empty the cache to ensure misses (hence non-responses) */
2878 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2880 keys_st
keys(key_count
);
2882 oldalarm
= signal(SIGALRM
, fail
);
2885 test_compare_got(MEMCACHED_SUCCESS
,
2886 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2887 memcached_last_error_message(memc_clone
));
2890 signal(SIGALRM
, oldalarm
);
2892 memcached_return_t rc
;
2894 char return_key
[MEMCACHED_MAX_KEY
];
2895 size_t return_key_length
;
2897 size_t return_value_length
;
2898 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2899 &return_value_length
, &flags
, &rc
)))
2901 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2903 test_compare(MEMCACHED_NOTFOUND
, rc
);
2904 test_zero(return_value_length
);
2905 test_zero(return_key_length
);
2906 test_false(return_key
[0]);
2907 test_false(return_value
);
2909 memcached_free(memc_clone
);
2911 return TEST_SUCCESS
;
2915 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2917 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2919 /* should work as of r580 */
2920 test_compare(TEST_SUCCESS
,
2921 _user_supplied_bug21(memc
, 10));
2923 /* should fail as of r580 */
2924 test_compare(TEST_SUCCESS
,
2925 _user_supplied_bug21(memc
, 1000));
2927 return TEST_SUCCESS
;
2930 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2932 memcached_st
*memc
= memcached_create(NULL
);
2936 test_compare(MEMCACHED_SUCCESS
,
2937 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2939 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2940 test_compare(value
, uint64_t(1));
2942 test_compare(MEMCACHED_SUCCESS
,
2943 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2945 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2946 test_true(value
== MEMCACHED_HASH_MD5
);
2949 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2951 memcached_server_st
*server_pool
;
2952 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");
2953 memcached_server_push(memc
, server_pool
);
2955 // @todo this needs to be refactored to actually test something.
2958 if ((fp
= fopen("ketama_keys.txt", "w")))
2962 printf("cannot write to file ketama_keys.txt");
2963 return TEST_FAILURE
;
2966 for (int x
= 0; x
< 10000; x
++)
2969 snprintf(key
, sizeof(key
), "%d", x
);
2971 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2972 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2973 in_port_t port
= memc
->hosts
[server_idx
].port
;
2974 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2975 memcached_server_instance_st instance
=
2976 memcached_server_instance_by_position(memc
, host_index
);
2980 memcached_server_list_free(server_pool
);
2981 memcached_free(memc
);
2983 return TEST_SUCCESS
;
2987 test_return_t
result_static(memcached_st
*memc
)
2989 memcached_result_st result
;
2990 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
2991 test_false(result
.options
.is_allocated
);
2992 test_true(memcached_is_initialized(&result
));
2993 test_true(result_ptr
);
2994 test_true(result_ptr
== &result
);
2996 memcached_result_free(&result
);
2998 test_false(result
.options
.is_allocated
);
2999 test_false(memcached_is_initialized(&result
));
3001 return TEST_SUCCESS
;
3004 test_return_t
result_alloc(memcached_st
*memc
)
3006 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3007 test_true(result_ptr
);
3008 test_true(result_ptr
->options
.is_allocated
);
3009 test_true(memcached_is_initialized(result_ptr
));
3010 memcached_result_free(result_ptr
);
3012 return TEST_SUCCESS
;
3016 test_return_t
add_host_test1(memcached_st
*memc
)
3018 memcached_return_t rc
;
3019 char servername
[]= "0.example.com";
3021 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3023 test_compare(1U, memcached_server_list_count(servers
));
3025 for (uint32_t x
= 2; x
< 20; x
++)
3027 char buffer
[SMALL_STRING_LEN
];
3029 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3030 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3032 test_compare(MEMCACHED_SUCCESS
, rc
);
3033 test_compare(x
, memcached_server_list_count(servers
));
3036 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3037 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3039 memcached_server_list_free(servers
);
3041 return TEST_SUCCESS
;
3045 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3049 #ifdef HARD_MALLOC_TESTS
3050 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3058 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3062 #ifdef HARD_MALLOC_TESTS
3063 void *ret
= malloc(size
+ 8);
3066 ret
= (void*)((caddr_t
)ret
+ 8);
3069 void *ret
= malloc(size
);
3074 memset(ret
, 0xff, size
);
3081 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3083 #ifdef HARD_MALLOC_TESTS
3084 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3085 void *nmem
= realloc(real_ptr
, size
+ 8);
3090 ret
= (void*)((caddr_t
)nmem
+ 8);
3096 return realloc(mem
, size
);
3101 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3103 #ifdef HARD_MALLOC_TESTS
3104 void *mem
= my_malloc(ptr
, nelem
* size
);
3107 memset(mem
, 0, nelem
* size
);
3113 return calloc(nelem
, size
);
3117 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3119 memcached_return_t rc
;
3120 const char *key
= "mine";
3123 /* Make sure be default none exists */
3124 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3126 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3128 /* Test a clean set */
3129 test_compare(MEMCACHED_SUCCESS
,
3130 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3132 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3134 test_memcmp(value
, key
, 4);
3135 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3137 /* Test that we can turn it off */
3138 test_compare(MEMCACHED_SUCCESS
,
3139 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3141 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3143 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3145 /* Now setup for main test */
3146 test_compare(MEMCACHED_SUCCESS
,
3147 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3149 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3151 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3152 test_memcmp(value
, key
, 4);
3154 /* Set to Zero, and then Set to something too large */
3157 memset(long_key
, 0, 255);
3159 test_compare(MEMCACHED_SUCCESS
,
3160 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3162 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3164 test_compare(MEMCACHED_SUCCESS
, rc
);
3166 /* Test a long key for failure */
3167 /* TODO, extend test to determine based on setting, what result should be */
3168 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3169 test_compare(MEMCACHED_SUCCESS
,
3170 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3172 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3173 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3174 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3175 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3177 /* Test for a bad prefix, but with a short key */
3178 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3179 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3181 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3182 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3185 return TEST_SUCCESS
;
3188 test_return_t
set_namespace(memcached_st
*memc
)
3190 memcached_return_t rc
;
3191 const char *key
= "mine";
3194 // Make sure we default to a null namespace
3195 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3197 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3199 /* Test a clean set */
3200 test_compare(MEMCACHED_SUCCESS
,
3201 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3203 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3205 test_memcmp(value
, key
, 4);
3206 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3208 return TEST_SUCCESS
;
3211 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3213 test_return_if(pre_binary(memc
));
3214 test_return_if(set_namespace(memc
));
3216 return TEST_SUCCESS
;
3219 #ifdef MEMCACHED_ENABLE_DEPRECATED
3220 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3222 void *test_ptr
= NULL
;
3225 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
3226 cb_ptr
= *(void **)&malloc_cb
;
3227 memcached_return_t rc
;
3229 test_compare(MEMCACHED_SUCCESS
,
3230 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3231 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3232 test_compare(MEMCACHED_SUCCESS
, rc
);
3233 test_true(test_ptr
== cb_ptr
);
3237 memcached_realloc_fn realloc_cb
=
3238 (memcached_realloc_fn
)my_realloc
;
3239 cb_ptr
= *(void **)&realloc_cb
;
3240 memcached_return_t rc
;
3242 test_compare(MEMCACHED_SUCCESS
,
3243 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3244 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3245 test_compare(MEMCACHED_SUCCESS
, rc
);
3246 test_true(test_ptr
== cb_ptr
);
3250 memcached_free_fn free_cb
=
3251 (memcached_free_fn
)my_free
;
3252 cb_ptr
= *(void **)&free_cb
;
3253 memcached_return_t rc
;
3255 test_compare(MEMCACHED_SUCCESS
,
3256 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3257 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3258 test_compare(MEMCACHED_SUCCESS
, rc
);
3259 test_true(test_ptr
== cb_ptr
);
3262 return TEST_SUCCESS
;
3267 test_return_t
set_memory_alloc(memcached_st
*memc
)
3269 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3270 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3271 my_realloc
, my_calloc
, NULL
));
3273 test_compare(MEMCACHED_SUCCESS
,
3274 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3275 my_realloc
, my_calloc
, NULL
));
3277 memcached_malloc_fn mem_malloc
;
3278 memcached_free_fn mem_free
;
3279 memcached_realloc_fn mem_realloc
;
3280 memcached_calloc_fn mem_calloc
;
3281 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3282 &mem_realloc
, &mem_calloc
);
3284 test_true(mem_malloc
== my_malloc
);
3285 test_true(mem_realloc
== my_realloc
);
3286 test_true(mem_calloc
== my_calloc
);
3287 test_true(mem_free
== my_free
);
3289 return TEST_SUCCESS
;
3292 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3295 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3296 memcached_hash_t hash
;
3297 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3298 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3301 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3302 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3304 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3306 if (hash
!= MEMCACHED_HASH_CRC
)
3307 return TEST_SKIPPED
;
3309 return TEST_SUCCESS
;
3312 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3315 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3316 memcached_hash_t hash
;
3317 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3318 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3323 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3324 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3326 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3328 if (hash
!= MEMCACHED_HASH_HSIEH
)
3329 return TEST_SKIPPED
;
3332 return TEST_SUCCESS
;
3335 test_return_t
enable_cas(memcached_st
*memc
)
3337 unsigned int set
= 1;
3339 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3341 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3343 return TEST_SUCCESS
;
3346 return TEST_SKIPPED
;
3349 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3351 memcached_version(memc
);
3353 memcached_server_instance_st instance
=
3354 memcached_server_instance_by_position(memc
, 0);
3356 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3357 or instance
->minor_version
> 2)
3359 return TEST_SUCCESS
;
3362 return TEST_SKIPPED
;
3365 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3367 const uint64_t timeout
= 100; // Not using, just checking that it sets
3369 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3371 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3373 return TEST_SUCCESS
;
3376 test_return_t
noreply_test(memcached_st
*memc
)
3378 test_compare(MEMCACHED_SUCCESS
,
3379 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3380 test_compare(MEMCACHED_SUCCESS
,
3381 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3382 test_compare(MEMCACHED_SUCCESS
,
3383 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3384 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3385 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3386 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3388 memcached_return_t ret
;
3389 for (int count
= 0; count
< 5; ++count
)
3391 for (size_t x
= 0; x
< 100; ++x
)
3393 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3394 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3395 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3397 size_t len
= (size_t)check_length
;
3402 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3405 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3408 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3411 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3414 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3420 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3421 memcached_strerror(NULL
, ret
));
3425 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3426 ** API and is _ONLY_ done this way to verify that the library works the
3427 ** way it is supposed to do!!!!
3431 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3433 memcached_server_instance_st instance
=
3434 memcached_server_instance_by_position(memc
, x
);
3435 no_msg
+=(int)(instance
->cursor_active
);
3438 test_true(no_msg
== 0);
3440 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3443 ** Now validate that all items was set properly!
3445 for (size_t x
= 0; x
< 100; ++x
)
3449 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3451 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3453 size_t len
= (size_t)check_length
;
3456 char* value
=memcached_get(memc
, key
, strlen(key
),
3457 &length
, &flags
, &ret
);
3458 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
3461 case 0: /* FALLTHROUGH */
3462 case 1: /* FALLTHROUGH */
3464 test_true(strncmp(value
, key
, len
) == 0);
3465 test_true(len
== length
);
3468 test_true(length
== len
* 2);
3471 test_true(length
== len
* 3);
3481 /* Try setting an illegal cas value (should not return an error to
3482 * the caller (because we don't expect a return message from the server)
3484 const char* keys
[]= {"0"};
3485 size_t lengths
[]= {1};
3488 memcached_result_st results_obj
;
3489 memcached_result_st
*results
;
3490 test_compare(MEMCACHED_SUCCESS
,
3491 memcached_mget(memc
, keys
, lengths
, 1));
3493 results
= memcached_result_create(memc
, &results_obj
);
3495 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3497 test_compare(MEMCACHED_SUCCESS
, ret
);
3498 uint64_t cas
= memcached_result_cas(results
);
3499 memcached_result_free(&results_obj
);
3501 test_compare(MEMCACHED_SUCCESS
,
3502 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3505 * The item will have a new cas value, so try to set it again with the old
3506 * value. This should fail!
3508 test_compare(MEMCACHED_SUCCESS
,
3509 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3510 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3511 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3512 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3515 return TEST_SUCCESS
;
3518 test_return_t
analyzer_test(memcached_st
*memc
)
3520 memcached_analysis_st
*report
;
3521 memcached_return_t rc
;
3523 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3524 test_compare(MEMCACHED_SUCCESS
, rc
);
3525 test_true(memc_stat
);
3527 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3528 test_compare(MEMCACHED_SUCCESS
, rc
);
3532 memcached_stat_free(NULL
, memc_stat
);
3534 return TEST_SUCCESS
;
3537 test_return_t
util_version_test(memcached_st
*memc
)
3539 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
3540 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3542 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3544 // We expect failure
3547 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3548 fprintf(stderr
, "\nDumping Server Information\n\n");
3549 memcached_server_fn callbacks
[1];
3551 callbacks
[0]= dump_server_information
;
3552 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3553 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3555 test_true(if_successful
== false);
3557 memcached_server_instance_st instance
=
3558 memcached_server_instance_by_position(memc
, 0);
3560 memcached_version(memc
);
3562 // We only use one binary when we test, so this should be just fine.
3563 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3564 test_true(if_successful
== true);
3566 if (instance
->micro_version
> 0)
3568 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3570 else if (instance
->minor_version
> 0)
3572 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3574 else if (instance
->major_version
> 0)
3576 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3579 test_true(if_successful
== true);
3581 if (instance
->micro_version
> 0)
3583 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3585 else if (instance
->minor_version
> 0)
3587 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3589 else if (instance
->major_version
> 0)
3591 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3594 test_true(if_successful
== false);
3596 return TEST_SUCCESS
;
3599 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3601 memcached_return_t rc
;
3602 memcached_server_instance_st instance
=
3603 memcached_server_instance_by_position(memc
, 0);
3605 // Test both the version that returns a code, and the one that does not.
3606 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3607 memcached_server_port(instance
) -1, NULL
) == -1);
3609 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3610 memcached_server_port(instance
) -1, &rc
) == -1);
3611 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3613 return TEST_SUCCESS
;
3617 test_return_t
getpid_test(memcached_st
*memc
)
3619 memcached_return_t rc
;
3620 memcached_server_instance_st instance
=
3621 memcached_server_instance_by_position(memc
, 0);
3623 // Test both the version that returns a code, and the one that does not.
3624 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3625 memcached_server_port(instance
), NULL
) > -1);
3627 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3628 memcached_server_port(instance
), &rc
) > -1);
3629 test_compare(MEMCACHED_SUCCESS
, rc
);
3631 return TEST_SUCCESS
;
3634 test_return_t
ping_test(memcached_st
*memc
)
3636 memcached_return_t rc
;
3637 memcached_server_instance_st instance
=
3638 memcached_server_instance_by_position(memc
, 0);
3640 // Test both the version that returns a code, and the one that does not.
3641 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3642 memcached_server_port(instance
), NULL
));
3644 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3645 memcached_server_port(instance
), &rc
));
3647 test_compare(MEMCACHED_SUCCESS
, rc
);
3649 return TEST_SUCCESS
;
3654 test_return_t
hash_sanity_test (memcached_st
*memc
)
3658 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3659 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3660 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3661 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3662 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3663 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3664 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3665 #ifdef HAVE_HSIEH_HASH
3666 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3668 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3669 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3670 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3672 return TEST_SUCCESS
;
3676 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3678 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3680 test_compare(MEMCACHED_SUCCESS
,
3681 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3682 (uint64_t)MEMCACHED_HASH_HSIEH
));
3684 return TEST_SUCCESS
;
3687 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3689 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3691 test_compare(MEMCACHED_SUCCESS
,
3692 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3694 return TEST_SUCCESS
;
3697 test_return_t
one_at_a_time_run (memcached_st
*)
3702 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3704 test_compare(one_at_a_time_values
[x
],
3705 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3708 return TEST_SUCCESS
;
3711 test_return_t
md5_run (memcached_st
*)
3716 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3718 test_compare(md5_values
[x
],
3719 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3722 return TEST_SUCCESS
;
3725 test_return_t
crc_run (memcached_st
*)
3730 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3732 test_compare(crc_values
[x
],
3733 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3736 return TEST_SUCCESS
;
3739 test_return_t
fnv1_64_run (memcached_st
*)
3741 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3746 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3748 test_compare(fnv1_64_values
[x
],
3749 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3752 return TEST_SUCCESS
;
3755 test_return_t
fnv1a_64_run (memcached_st
*)
3757 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3762 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3764 test_compare(fnv1a_64_values
[x
],
3765 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3768 return TEST_SUCCESS
;
3771 test_return_t
fnv1_32_run (memcached_st
*)
3776 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3778 test_compare(fnv1_32_values
[x
],
3779 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3782 return TEST_SUCCESS
;
3785 test_return_t
fnv1a_32_run (memcached_st
*)
3790 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3792 test_compare(fnv1a_32_values
[x
],
3793 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3796 return TEST_SUCCESS
;
3799 test_return_t
hsieh_run (memcached_st
*)
3801 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3806 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3808 test_compare(hsieh_values
[x
],
3809 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3812 return TEST_SUCCESS
;
3815 test_return_t
murmur_run (memcached_st
*)
3817 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3819 #ifdef WORDS_BIGENDIAN
3820 (void)murmur_values
;
3821 return TEST_SKIPPED
;
3826 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3828 test_compare(murmur_values
[x
],
3829 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3832 return TEST_SUCCESS
;
3836 test_return_t
jenkins_run (memcached_st
*)
3841 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3843 test_compare(jenkins_values
[x
],
3844 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3847 return TEST_SUCCESS
;
3850 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3852 return libhashkit_md5(string
, string_length
);
3855 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3857 return libhashkit_crc32(string
, string_length
);
3860 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3866 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3868 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};
3869 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};
3871 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3873 hashkit_clone(&new_kit
, kit
);
3874 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3876 memcached_set_hashkit(memc
, &new_kit
);
3879 Verify Setting the hash.
3881 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3885 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3886 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3891 Now check memcached_st.
3893 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3897 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3898 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3901 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3903 memcached_set_hashkit(memc
, &new_kit
);
3906 Verify Setting the hash.
3908 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3912 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3913 test_true(crc_values
[x
] == hash_val
);
3916 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3920 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3921 test_compare(crc_hosts
[x
], hash_val
);
3924 memcached_free(memc
);
3926 return TEST_SUCCESS
;
3930 Test case adapted from John Gorman <johngorman2@gmail.com>
3932 We are testing the error condition when we connect to a server via memcached_get()
3933 but find that the server is not available.
3935 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3937 const char *key
= "MemcachedLives";
3940 memcached_return rc
;
3943 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3945 // See if memcached is reachable.
3946 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
3950 test_true(memcached_failed(rc
));
3952 memcached_free(tl_memc_h
);
3954 return TEST_SUCCESS
;
3958 We connect to a server which exists, but search for a key that does not exist.
3960 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3962 const char *key
= "MemcachedKeyNotEXIST";
3965 memcached_return rc
;
3967 // See if memcached is reachable.
3968 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
3972 test_compare(MEMCACHED_NOTFOUND
, rc
);
3974 return TEST_SUCCESS
;
3978 Test case adapted from John Gorman <johngorman2@gmail.com>
3980 We are testing the error condition when we connect to a server via memcached_get_by_key()
3981 but find that the server is not available.
3983 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
3986 memcached_st
*tl_memc_h
;
3987 memcached_server_st
*servers
;
3989 const char *key
= "MemcachedLives";
3992 memcached_return rc
;
3996 tl_memc_h
= memcached_create(NULL
);
3997 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
3998 memcached_server_push(tl_memc_h
, servers
);
3999 memcached_server_list_free(servers
);
4001 // See if memcached is reachable.
4002 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4006 test_true(memcached_failed(rc
));
4008 memcached_free(tl_memc_h
);
4010 return TEST_SUCCESS
;
4014 We connect to a server which exists, but search for a key that does not exist.
4016 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4018 const char *key
= "MemcachedKeyNotEXIST";
4021 memcached_return rc
;
4024 // See if memcached is reachable.
4025 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4029 test_compare(MEMCACHED_NOTFOUND
, rc
);
4031 return TEST_SUCCESS
;
4034 test_return_t
regression_bug_434484(memcached_st
*memc
)
4036 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4038 const char *key
= "regression_bug_434484";
4039 size_t keylen
= strlen(key
);
4041 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4042 test_compare(MEMCACHED_NOTSTORED
, ret
);
4044 size_t size
= 2048 * 1024;
4045 char *data
= (char*)calloc(1, size
);
4047 test_compare(MEMCACHED_E2BIG
,
4048 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4051 return TEST_SUCCESS
;
4054 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4056 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4058 memcached_return_t rc
;
4060 memcached_execute_fn callbacks
[]= { &callback_counter
};
4063 * I only want to hit only _one_ server so I know the number of requests I'm
4064 * sending in the pipleine to the server. Let's try to do a multiget of
4065 * 1024 (that should satisfy most users don't you think?). Future versions
4066 * will include a mget_execute function call if you need a higher number.
4068 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4070 const size_t max_keys
= 1024;
4071 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4072 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4074 for (size_t x
= 0; x
< max_keys
; ++x
)
4078 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4084 * Run two times.. the first time we should have 100% cache miss,
4085 * and the second time we should have 100% cache hits
4087 for (size_t y
= 0; y
< 2; y
++)
4089 test_compare(MEMCACHED_SUCCESS
,
4090 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4092 // One the first run we should get a NOT_FOUND, but on the second some data
4093 // should be returned.
4094 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4095 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4099 /* The first iteration should give me a 100% cache miss. verify that*/
4100 char blob
[1024]= { 0 };
4102 test_false(counter
);
4104 for (size_t x
= 0; x
< max_keys
; ++x
)
4106 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4107 blob
, sizeof(blob
), 0, 0);
4108 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4113 /* Verify that we received all of the key/value pairs */
4114 test_compare(counter
, max_keys
);
4118 /* Release allocated resources */
4119 for (size_t x
= 0; x
< max_keys
; ++x
)
4126 memcached_free(memc
);
4128 return TEST_SUCCESS
;
4131 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4133 memcached_return_t rc
;
4134 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4135 test_compare(MEMCACHED_SUCCESS
, rc
);
4137 return regression_bug_434843(memc
);
4140 test_return_t
regression_bug_421108(memcached_st
*memc
)
4142 memcached_return_t rc
;
4143 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4144 test_compare(MEMCACHED_SUCCESS
, rc
);
4146 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4147 test_compare(MEMCACHED_SUCCESS
, rc
);
4148 test_true(bytes_str
);
4149 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4151 test_compare(MEMCACHED_SUCCESS
, rc
);
4152 test_true(bytes_read_str
);
4154 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4155 "bytes_written", &rc
);
4156 test_compare(MEMCACHED_SUCCESS
, rc
);
4157 test_true(bytes_written_str
);
4159 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4160 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4161 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4163 test_true(bytes
!= bytes_read
);
4164 test_true(bytes
!= bytes_written
);
4166 /* Release allocated resources */
4168 free(bytes_read_str
);
4169 free(bytes_written_str
);
4170 memcached_stat_free(NULL
, memc_stat
);
4172 return TEST_SUCCESS
;
4176 * The test case isn't obvious so I should probably document why
4177 * it works the way it does. Bug 442914 was caused by a bug
4178 * in the logic in memcached_purge (it did not handle the case
4179 * where the number of bytes sent was equal to the watermark).
4180 * In this test case, create messages so that we hit that case
4181 * and then disable noreply mode and issue a new command to
4182 * verify that it isn't stuck. If we change the format for the
4183 * delete command or the watermarks, we need to update this
4186 test_return_t
regression_bug_442914(memcached_st
*memc
)
4188 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4189 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4191 uint32_t number_of_hosts
= memcached_server_count(memc
);
4192 memc
->number_of_hosts
= 1;
4197 for (uint32_t x
= 0; x
< 250; ++x
)
4199 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4200 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4201 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4204 len
= snprintf(k
, sizeof(k
), "%037u", 251U);
4206 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4207 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4209 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4210 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
4212 memc
->number_of_hosts
= number_of_hosts
;
4214 return TEST_SUCCESS
;
4217 test_return_t
regression_bug_447342(memcached_st
*memc
)
4219 memcached_server_instance_st instance_one
;
4220 memcached_server_instance_st instance_two
;
4222 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4223 return TEST_SKIPPED
;
4225 test_compare(MEMCACHED_SUCCESS
,
4226 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4228 const unsigned int max_keys
= 100;
4229 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4230 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4232 for (unsigned int x
= 0; x
< max_keys
; ++x
)
4236 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4239 test_compare(MEMCACHED_SUCCESS
,
4240 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
4244 ** We are using the quiet commands to store the replicas, so we need
4245 ** to ensure that all of them are processed before we can continue.
4246 ** In the test we go directly from storing the object to trying to
4247 ** receive the object from all of the different servers, so we
4248 ** could end up in a race condition (the memcached server hasn't yet
4249 ** processed the quiet command from the replication set when it process
4250 ** the request from the other client (created by the clone)). As a
4251 ** workaround for that we call memcached_quit to send the quit command
4252 ** to the server and wait for the response ;-) If you use the test code
4253 ** as an example for your own code, please note that you shouldn't need
4256 memcached_quit(memc
);
4258 /* Verify that all messages are stored, and we didn't stuff too much
4261 test_compare(MEMCACHED_SUCCESS
,
4262 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4264 unsigned int counter
= 0;
4265 memcached_execute_fn callbacks
[]= { &callback_counter
};
4266 test_compare(MEMCACHED_SUCCESS
,
4267 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4269 /* Verify that we received all of the key/value pairs */
4270 test_compare(counter
, max_keys
);
4272 memcached_quit(memc
);
4274 * Don't do the following in your code. I am abusing the internal details
4275 * within the library, and this is not a supported interface.
4276 * This is to verify correct behavior in the library. Fake that two servers
4279 instance_one
= memcached_server_instance_by_position(memc
, 0);
4280 instance_two
= memcached_server_instance_by_position(memc
, 2);
4281 in_port_t port0
= instance_one
->port
;
4282 in_port_t port2
= instance_two
->port
;
4284 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4285 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4287 test_compare(MEMCACHED_SUCCESS
,
4288 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4291 test_compare(MEMCACHED_SUCCESS
,
4292 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4293 test_compare(counter
, (unsigned int)max_keys
);
4295 /* restore the memc handle */
4296 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4297 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4299 memcached_quit(memc
);
4301 /* Remove half of the objects */
4302 for (size_t x
= 0; x
< max_keys
; ++x
)
4306 test_compare(MEMCACHED_SUCCESS
,
4307 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
4311 memcached_quit(memc
);
4312 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4313 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4315 /* now retry the command, this time we should have cache misses */
4316 test_compare(MEMCACHED_SUCCESS
,
4317 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4320 test_compare(MEMCACHED_SUCCESS
,
4321 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4322 test_compare(counter
, (unsigned int)(max_keys
>> 1));
4324 /* Release allocated resources */
4325 for (size_t x
= 0; x
< max_keys
; ++x
)
4332 /* restore the memc handle */
4333 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4334 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4336 return TEST_SUCCESS
;
4339 test_return_t
regression_bug_463297(memcached_st
*memc
)
4341 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4343 // Since we blocked timed delete, this test is no longer valid.
4345 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4346 test_true(memc_clone
);
4347 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4349 memcached_server_instance_st instance
=
4350 memcached_server_instance_by_position(memc_clone
, 0);
4352 if (instance
->major_version
> 1 ||
4353 (instance
->major_version
== 1 &&
4354 instance
->minor_version
> 2))
4356 /* Binary protocol doesn't support deferred delete */
4357 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4358 test_true(bin_clone
);
4359 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4360 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4361 memcached_free(bin_clone
);
4363 memcached_quit(memc_clone
);
4365 /* If we know the server version, deferred delete should fail
4366 * with invalid arguments */
4367 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4369 /* If we don't know the server version, we should get a protocol error */
4370 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4372 /* but there is a bug in some of the memcached servers (1.4) that treats
4373 * the counter as noreply so it doesn't send the proper error message
4375 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4377 /* And buffered mode should be disabled and we should get protocol error */
4378 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4379 rc
= memcached_delete(memc
, "foo", 3, 1);
4380 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4382 /* Same goes for noreply... */
4383 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4384 rc
= memcached_delete(memc
, "foo", 3, 1);
4385 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4387 /* but a normal request should go through (and be buffered) */
4388 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4389 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4391 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4392 /* unbuffered noreply should be success */
4393 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4394 /* unbuffered with reply should be not found... */
4395 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4396 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4399 memcached_free(memc_clone
);
4402 return TEST_SUCCESS
;
4406 /* Test memcached_server_get_last_disconnect
4407 * For a working server set, shall be NULL
4408 * For a set of non existing server, shall not be NULL
4410 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4412 memcached_return_t rc
;
4413 memcached_server_instance_st disconnected_server
;
4415 /* With the working set of server */
4416 const char *key
= "marmotte";
4417 const char *value
= "milka";
4419 memcached_reset_last_disconnected_server(memc
);
4420 test_false(memc
->last_disconnected_server
);
4421 rc
= memcached_set(memc
, key
, strlen(key
),
4422 value
, strlen(value
),
4423 (time_t)0, (uint32_t)0);
4424 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4426 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4427 test_false(disconnected_server
);
4429 /* With a non existing server */
4431 memcached_server_st
*servers
;
4433 const char *server_list
= "localhost:9";
4435 servers
= memcached_servers_parse(server_list
);
4437 mine
= memcached_create(NULL
);
4438 rc
= memcached_server_push(mine
, servers
);
4439 test_compare(MEMCACHED_SUCCESS
, rc
);
4440 memcached_server_list_free(servers
);
4443 rc
= memcached_set(mine
, key
, strlen(key
),
4444 value
, strlen(value
),
4445 (time_t)0, (uint32_t)0);
4446 test_true(memcached_failed(rc
));
4448 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4449 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4450 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4451 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4453 memcached_quit(mine
);
4454 memcached_free(mine
);
4456 return TEST_SUCCESS
;
4459 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4461 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4462 char buffer
[BUFSIZ
];
4464 test_compare(MEMCACHED_SUCCESS
,
4465 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4467 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4470 // We will just use the error strings as our keys
4471 uint32_t counter
= 100;
4474 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4476 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4477 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4478 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4480 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
4481 test_true(disconnected_server
);
4482 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4483 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4487 memcached_reset_last_disconnected_server(memc
);
4492 memcached_free(memc
);
4494 return TEST_SUCCESS
;
4497 test_return_t
test_verbosity(memcached_st
*memc
)
4499 memcached_verbosity(memc
, 3);
4501 return TEST_SUCCESS
;
4505 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
4506 const char *key
, size_t key_length
,
4507 const char *value
, size_t value_length
,
4517 return MEMCACHED_SUCCESS
;
4520 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4522 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4523 test_compare(MEMCACHED_SUCCESS
, rc
);
4525 test_compare(MEMCACHED_SUCCESS
,
4526 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4528 test_compare(MEMCACHED_SUCCESS
,
4529 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4531 test_compare(MEMCACHED_SUCCESS
,
4532 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4534 return TEST_SUCCESS
;
4538 * This test ensures that the failure counter isn't incremented during
4539 * normal termination of the memcached instance.
4541 test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
4543 memcached_return_t rc
;
4544 memcached_server_instance_st instance
;
4546 /* Set value to force connection to the server */
4547 const char *key
= "marmotte";
4548 const char *value
= "milka";
4551 * Please note that I'm abusing the internal structures in libmemcached
4552 * in a non-portable way and you shouldn't be doing this. I'm only
4553 * doing this in order to verify that the library works the way it should
4555 uint32_t number_of_hosts
= memcached_server_count(memc
);
4556 memc
->number_of_hosts
= 1;
4558 /* Ensure that we are connected to the server by setting a value */
4559 rc
= memcached_set(memc
, key
, strlen(key
),
4560 value
, strlen(value
),
4561 (time_t)0, (uint32_t)0);
4562 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4565 instance
= memcached_server_instance_by_position(memc
, 0);
4566 /* The test is to see that the memcached_quit doesn't increase the
4567 * the server failure conter, so let's ensure that it is zero
4568 * before sending quit
4570 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4572 memcached_quit(memc
);
4574 /* Verify that it memcached_quit didn't increment the failure counter
4575 * Please note that this isn't bullet proof, because an error could
4578 test_zero(instance
->server_failure_counter
);
4580 /* restore the instance */
4581 memc
->number_of_hosts
= number_of_hosts
;
4583 return TEST_SUCCESS
;
4587 * This tests ensures expected disconnections (for some behavior changes
4588 * for instance) do not wrongly increase failure counter
4590 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4592 /* Set value to force connection to the server */
4593 const char *key
= "marmotte";
4594 const char *value
= "milka";
4596 test_compare_hint(MEMCACHED_SUCCESS
,
4597 memcached_set(memc
, key
, strlen(key
),
4598 value
, strlen(value
),
4599 (time_t)0, (uint32_t)0),
4600 memcached_last_error_message(memc
));
4603 /* put failure limit to 1 */
4604 test_compare(MEMCACHED_SUCCESS
,
4605 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4607 /* Put a retry timeout to effectively activate failure_limit effect */
4608 test_compare(MEMCACHED_SUCCESS
,
4609 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4611 /* change behavior that triggers memcached_quit()*/
4612 test_compare(MEMCACHED_SUCCESS
,
4613 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4616 /* Check if we still are connected */
4618 size_t string_length
;
4619 memcached_return rc
;
4620 char *string
= memcached_get(memc
, key
, strlen(key
),
4621 &string_length
, &flags
, &rc
);
4623 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4627 return TEST_SUCCESS
;
4632 * Test that ensures mget_execute does not end into recursive calls that finally fails
4634 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4638 return TEST_SKIPPED
; // My MAC can't handle this test
4641 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4644 * I only want to hit _one_ server so I know the number of requests I'm
4645 * sending in the pipeline.
4647 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4650 size_t max_keys
= 20480;
4652 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
4653 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4655 /* First add all of the items.. */
4656 char blob
[1024]= { 0 };
4657 for (size_t x
= 0; x
< max_keys
; ++x
)
4660 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4663 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
4664 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4669 /* Try to get all of them with a large multiget */
4671 memcached_execute_function callbacks
[]= { &callback_counter
};
4672 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
4673 (size_t)max_keys
, callbacks
, &counter
, 1);
4674 test_compare(MEMCACHED_SUCCESS
, rc
);
4676 char* the_value
= NULL
;
4677 char the_key
[MEMCACHED_MAX_KEY
];
4678 size_t the_key_length
;
4679 size_t the_value_length
;
4683 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4685 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4691 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4694 test_compare(MEMCACHED_END
, rc
);
4696 /* Verify that we got all of the items */
4697 test_compare(counter
, max_keys
);
4700 /* Release all allocated resources */
4701 for (size_t x
= 0; x
< max_keys
; ++x
)
4708 memcached_free(memc
);
4710 return TEST_SUCCESS
;
4713 test_return_t
regression_bug_583031(memcached_st
*)
4715 memcached_st
*memc
= memcached_create(NULL
);
4717 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
4719 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
4720 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4721 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4722 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4723 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4724 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4726 memcached_return_t rc
;
4730 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4734 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
4736 memcached_free(memc
);
4738 return TEST_SUCCESS
;
4741 test_return_t
regression_bug_581030(memcached_st
*)
4744 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4745 test_false(local_stat
);
4747 memcached_stat_free(NULL
, NULL
);
4750 return TEST_SUCCESS
;
4753 #define regression_bug_655423_COUNT 6000
4754 test_return_t
regression_bug_655423(memcached_st
*memc
)
4756 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4757 memc
= NULL
; // Just to make sure it is not used
4762 return TEST_SKIPPED
;
4765 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4766 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4767 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4768 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4770 memset(payload
, int('x'), sizeof(payload
));
4772 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
4774 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
4775 snprintf(key
, sizeof(key
), "%u", x
);
4777 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
4780 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
4782 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
4783 snprintf(key
, sizeof(key
), "%u", x
);
4785 size_t value_length
;
4786 memcached_return_t rc
;
4787 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
4789 if (rc
== MEMCACHED_NOTFOUND
)
4792 test_zero(value_length
);
4796 test_compare(MEMCACHED_SUCCESS
, rc
);
4798 test_compare(100LLU, value_length
);
4802 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
4803 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
4804 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
4806 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
4807 snprintf(key
, sizeof(key
), "%u", x
);
4809 keys
[x
]= strdup(key
);
4811 key_length
[x
]= strlen(key
);
4812 test_true(key_length
[x
]);
4815 test_compare(MEMCACHED_SUCCESS
,
4816 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
4819 memcached_result_st
*result
= NULL
;
4820 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4822 test_compare(size_t(100), memcached_result_length(result
));
4826 test_true(count
> 100); // If we don't get back atleast this, something is up
4828 /* Release all allocated resources */
4829 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
4837 memcached_free(clone
);
4839 return TEST_SUCCESS
;
4843 * Test that ensures that buffered set to not trigger problems during io_flush
4845 #define regression_bug_490520_COUNT 200480
4846 test_return_t
regression_bug_490520(memcached_st
*memc
)
4848 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4849 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4850 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4851 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4852 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4854 memc
->number_of_hosts
= 1;
4856 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
4857 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
4859 /* First add all of the items.. */
4860 char blob
[3333] = {0};
4861 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4864 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
4868 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
4869 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4872 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4879 return TEST_SUCCESS
;
4883 test_return_t
regression_bug_854604(memcached_st
*)
4887 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4889 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4891 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4892 test_compare(buffer
[0], 0);
4894 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4895 test_true(strlen(buffer
));
4897 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4898 test_true(strlen(buffer
));
4900 return TEST_SUCCESS
;
4903 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4905 fprintf(stderr
, "Iteration #%u: ", it
);
4907 if (error
== MEMCACHED_ERRNO
)
4909 fprintf(stderr
, "system error %d from %s: %s\n",
4910 errno
, what
, strerror(errno
));
4914 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4915 memcached_strerror(mc
, error
));
4919 #define TEST_CONSTANT_CREATION 200
4921 test_return_t
regression_bug_(memcached_st
*memc
)
4923 const char *remote_server
;
4926 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4928 return TEST_SKIPPED
;
4931 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4933 memcached_st
* mc
= memcached_create(NULL
);
4934 memcached_return rc
;
4936 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4937 if (rc
!= MEMCACHED_SUCCESS
)
4939 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
4942 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4943 if (rc
!= MEMCACHED_SUCCESS
)
4945 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
4948 rc
= memcached_server_add(mc
, remote_server
, 0);
4949 if (rc
!= MEMCACHED_SUCCESS
)
4951 memcached_die(mc
, rc
, "memcached_server_add", x
);
4954 const char *set_key
= "akey";
4955 const size_t set_key_len
= strlen(set_key
);
4956 const char *set_value
= "a value";
4957 const size_t set_value_len
= strlen(set_value
);
4959 if (rc
== MEMCACHED_SUCCESS
)
4963 size_t get_value_len
;
4965 uint32_t get_value_flags
;
4967 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
4968 &get_value_flags
, &rc
);
4969 if (rc
!= MEMCACHED_SUCCESS
)
4971 memcached_die(mc
, rc
, "memcached_get", x
);
4977 (get_value_len
!= set_value_len
4978 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
4980 fprintf(stderr
, "Values don't match?\n");
4981 rc
= MEMCACHED_FAILURE
;
4987 rc
= memcached_set(mc
,
4988 set_key
, set_key_len
,
4989 set_value
, set_value_len
,
4993 if (rc
!= MEMCACHED_SUCCESS
)
4995 memcached_die(mc
, rc
, "memcached_set", x
);
5002 if (rc
!= MEMCACHED_SUCCESS
)
5008 return TEST_SUCCESS
;