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.
38 #include "mem_config.h"
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"
55 #include "libtest/memcached.hpp"
60 #include <semaphore.h>
64 #include <sys/types.h>
69 #include "libtest/server.h"
71 #include "bin/generator.h"
73 #define SMALL_STRING_LEN 1024
75 #include "libtest/test.hpp"
77 using namespace libtest
;
79 #include "libmemcachedutil-1.0/util.h"
81 #include "tests/hash_results.h"
83 #include "tests/libmemcached-1.0/callback_counter.h"
84 #include "tests/libmemcached-1.0/fetch_all_results.h"
85 #include "tests/libmemcached-1.0/mem_functions.h"
86 #include "tests/libmemcached-1.0/setup_and_teardowns.h"
87 #include "tests/print.h"
88 #include "tests/debug.h"
89 #include "tests/memc.hpp"
91 #define UUID_STRING_MAXLENGTH 36
93 #include "tests/keys.hpp"
95 #include "libmemcached/instance.hpp"
98 test_return_t
mget_end(memcached_st
*memc
)
100 const char *keys
[]= { "foo", "foo2" };
101 size_t lengths
[]= { 3, 4 };
102 const char *values
[]= { "fjord", "41" };
105 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
107 test_compare(MEMCACHED_SUCCESS
,
110 values
[x
], strlen(values
[x
]),
111 time_t(0), uint32_t(0)));
115 size_t string_length
;
118 // retrieve both via mget
119 test_compare(MEMCACHED_SUCCESS
,
122 test_array_length(keys
)));
124 char key
[MEMCACHED_MAX_KEY
];
126 memcached_return_t rc
;
128 // this should get both
129 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
131 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
133 test_compare(MEMCACHED_SUCCESS
, rc
);
140 test_compare(string_length
, strlen(values
[val
]));
141 test_true(strncmp(values
[val
], string
, string_length
) == 0);
145 // this should indicate end
146 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
147 test_compare(MEMCACHED_END
, rc
);
151 test_compare(MEMCACHED_SUCCESS
,
152 memcached_mget(memc
, keys
, lengths
, 1));
154 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
155 test_compare(key_length
, lengths
[0]);
156 test_true(strncmp(keys
[0], key
, key_length
) == 0);
157 test_compare(string_length
, strlen(values
[0]));
158 test_true(strncmp(values
[0], string
, string_length
) == 0);
159 test_compare(MEMCACHED_SUCCESS
, rc
);
162 // this should indicate end
163 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
164 test_compare(MEMCACHED_END
, rc
);
170 test_return_t
mget_result_test(memcached_st
*memc
)
172 const char *keys
[]= {"fudge", "son", "food"};
173 size_t key_length
[]= {5, 3, 4};
175 memcached_result_st results_obj
;
176 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
178 test_true(&results_obj
== results
);
180 /* We need to empty the server before continueing test */
181 test_compare(MEMCACHED_SUCCESS
,
182 memcached_flush(memc
, 0));
184 test_compare(MEMCACHED_SUCCESS
,
185 memcached_mget(memc
, keys
, key_length
, 3));
187 memcached_return_t rc
;
188 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
193 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
195 test_compare(MEMCACHED_NOTFOUND
, rc
);
197 for (uint32_t x
= 0; x
< 3; x
++)
199 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
200 keys
[x
], key_length
[x
],
201 (time_t)50, (uint32_t)9);
202 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
205 test_compare(MEMCACHED_SUCCESS
,
206 memcached_mget(memc
, keys
, key_length
, 3));
208 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
211 test_true(&results_obj
== results
);
212 test_compare(MEMCACHED_SUCCESS
, rc
);
213 test_memcmp(memcached_result_key_value(results
),
214 memcached_result_value(results
),
215 memcached_result_length(results
));
216 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
219 memcached_result_free(&results_obj
);
224 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
226 const char *keys
[]= {"fudge", "son", "food"};
227 size_t key_length
[]= {5, 3, 4};
229 memcached_result_st
*results
;
231 /* We need to empty the server before continueing test */
232 test_compare(MEMCACHED_SUCCESS
,
233 memcached_flush(memc
, 0));
235 test_compare(MEMCACHED_SUCCESS
,
236 memcached_mget(memc
, keys
, key_length
, 3));
238 memcached_return_t rc
;
239 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
244 test_compare(MEMCACHED_NOTFOUND
, rc
);
246 for (uint32_t x
= 0; x
< 3; x
++)
248 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
249 keys
[x
], key_length
[x
],
250 (time_t)50, (uint32_t)9);
251 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
254 test_compare(MEMCACHED_SUCCESS
,
255 memcached_mget(memc
, keys
, key_length
, 3));
258 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
261 test_compare(MEMCACHED_SUCCESS
, rc
);
262 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
263 test_memcmp(memcached_result_key_value(results
),
264 memcached_result_value(results
),
265 memcached_result_length(results
));
266 memcached_result_free(results
);
273 test_return_t
mget_result_function(memcached_st
*memc
)
275 const char *keys
[]= {"fudge", "son", "food"};
276 size_t key_length
[]= {5, 3, 4};
278 memcached_execute_fn callbacks
[1];
280 for (uint32_t x
= 0; x
< 3; x
++)
282 test_compare(return_value_based_on_buffering(memc
),
283 memcached_set(memc
, keys
[x
], key_length
[x
],
284 keys
[x
], key_length
[x
],
285 time_t(50), uint32_t(9)));
287 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
288 memcached_quit(memc
);
290 test_compare(MEMCACHED_SUCCESS
,
291 memcached_mget(memc
, keys
, key_length
, 3));
293 callbacks
[0]= &callback_counter
;
296 test_compare(MEMCACHED_SUCCESS
,
297 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
299 test_compare(size_t(3), counter
);
304 test_return_t
mget_test(memcached_st
*memc
)
306 const char *keys
[]= {"fudge", "son", "food"};
307 size_t key_length
[]= {5, 3, 4};
309 char return_key
[MEMCACHED_MAX_KEY
];
310 size_t return_key_length
;
312 size_t return_value_length
;
314 test_compare(MEMCACHED_SUCCESS
,
315 memcached_mget(memc
, keys
, key_length
, 3));
318 memcached_return_t rc
;
319 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
320 &return_value_length
, &flags
, &rc
)))
322 test_true(return_value
);
324 test_false(return_value
);
325 test_zero(return_value_length
);
326 test_compare(MEMCACHED_NOTFOUND
, rc
);
328 for (uint32_t x
= 0; x
< 3; x
++)
330 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
331 keys
[x
], key_length
[x
],
332 (time_t)50, (uint32_t)9);
333 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
335 test_compare(MEMCACHED_SUCCESS
,
336 memcached_mget(memc
, keys
, key_length
, 3));
339 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
340 &return_value_length
, &flags
, &rc
)))
342 test_true(return_value
);
343 test_compare(MEMCACHED_SUCCESS
, rc
);
344 if (not memc
->_namespace
)
346 test_compare(return_key_length
, return_value_length
);
347 test_memcmp(return_value
, return_key
, return_value_length
);
356 test_return_t
mget_execute(memcached_st
*original_memc
)
358 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
360 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
365 /* First add all of the items.. */
366 char blob
[1024] = {0};
368 for (size_t x
= 0; x
< keys
.size(); ++x
)
370 uint64_t query_id
= memcached_query_id(memc
);
371 memcached_return_t rc
= memcached_add(memc
,
372 keys
.key_at(x
), keys
.length_at(x
),
375 ASSERT_TRUE_(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, "Returned %s", memcached_strerror(NULL
, rc
));
376 test_compare(query_id
+1, memcached_query_id(memc
));
379 /* Try to get all of them with a large multiget */
381 memcached_execute_fn callbacks
[]= { &callback_counter
};
382 test_compare(MEMCACHED_SUCCESS
,
383 memcached_mget_execute(memc
,
384 keys
.keys_ptr(), keys
.lengths_ptr(),
385 keys
.size(), callbacks
, &counter
, 1));
388 uint64_t query_id
= memcached_query_id(memc
);
389 test_compare(MEMCACHED_SUCCESS
,
390 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
391 test_compare(query_id
, memcached_query_id(memc
));
393 /* Verify that we got all of the items */
394 test_compare(keys
.size(), counter
);
397 memcached_free(memc
);
404 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
406 memcached_return_t rc
;
408 const char *key
= "not_found";
409 size_t key_length
= test_literal_param_size("not_found");
411 test_compare(MEMCACHED_SUCCESS
,
412 memcached_mget(memc
, &key
, &key_length
, 1));
414 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
416 test_compare(MEMCACHED_NOTFOUND
, rc
);
418 memcached_result_free(result
);
424 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
426 test_return_t
user_supplied_bug12(memcached_st
*memc
)
428 memcached_return_t rc
;
432 uint64_t number_value
;
434 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
435 &value_length
, &flags
, &rc
);
437 test_compare(MEMCACHED_NOTFOUND
, rc
);
439 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
442 /* The binary protocol will set the key if it doesn't exist */
443 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
445 test_compare(MEMCACHED_SUCCESS
, rc
);
449 test_compare(MEMCACHED_NOTFOUND
, rc
);
452 test_compare(MEMCACHED_SUCCESS
,
453 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
455 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
459 test_compare(MEMCACHED_SUCCESS
,
460 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
461 test_compare(2UL, number_value
);
467 Bug found where command total one more than MEMCACHED_MAX_BUFFER
468 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
470 test_return_t
user_supplied_bug13(memcached_st
*memc
)
472 char key
[] = "key34567890";
474 char commandFirst
[]= "set key34567890 0 0 ";
475 char commandLast
[] = " \r\n"; /* first line of command sent to server */
476 size_t commandLength
;
478 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
480 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
482 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
484 char *overflow
= new (std::nothrow
) char[testSize
];
487 memset(overflow
, 'x', testSize
);
488 test_compare(MEMCACHED_SUCCESS
,
489 memcached_set(memc
, key
, strlen(key
),
490 overflow
, testSize
, 0, 0));
499 Test values of many different sizes
500 Bug found where command total one more than MEMCACHED_MAX_BUFFER
501 set key34567890 0 0 8169 \r\n
502 is sent followed by buffer of size 8169, followed by 8169
504 test_return_t
user_supplied_bug14(memcached_st
*memc
)
506 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
508 libtest::vchar_t value
;
509 value
.reserve(18000);
510 for (ptrdiff_t x
= 0; x
< 18000; x
++)
512 value
.push_back((char) (x
% 127));
515 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
517 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
518 &value
[0], current_length
,
519 (time_t)0, (uint32_t)0);
520 ASSERT_TRUE_(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, "Instead got %s", memcached_strerror(NULL
, rc
));
522 size_t string_length
;
524 char *string
= memcached_get(memc
, test_literal_param("foo"),
525 &string_length
, &flags
, &rc
);
527 test_compare(MEMCACHED_SUCCESS
, rc
);
528 test_compare(string_length
, current_length
);
530 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
531 test_memcmp(string
, &value
[0], string_length
);
543 test_return_t
user_supplied_bug19(memcached_st
*)
545 memcached_return_t res
;
547 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
549 const memcached_instance_st
* server
= memcached_server_by_key(memc
, "a", 1, &res
);
552 memcached_free(memc
);
557 /* CAS test from Andei */
558 test_return_t
user_supplied_bug20(memcached_st
*memc
)
560 const char *key
= "abc";
561 size_t key_len
= strlen("abc");
563 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
565 test_compare(MEMCACHED_SUCCESS
,
567 test_literal_param("abc"),
568 test_literal_param("foobar"),
569 (time_t)0, (uint32_t)0));
571 test_compare(MEMCACHED_SUCCESS
,
572 memcached_mget(memc
, &key
, &key_len
, 1));
574 memcached_result_st result_obj
;
575 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
578 memcached_result_create(memc
, &result_obj
);
579 memcached_return_t status
;
580 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
583 test_compare(MEMCACHED_SUCCESS
, status
);
585 memcached_result_free(result
);
590 /* Large mget() of missing keys with binary proto
592 * If many binary quiet commands (such as getq's in an mget) fill the output
593 * buffer and the server chooses not to respond, memcached_flush hangs. See
594 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
597 /* sighandler_t function that always asserts false */
598 static __attribute__((noreturn
)) void fail(int)
604 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
611 void (*oldalarm
)(int);
613 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
614 test_true(memc_clone
);
616 /* only binproto uses getq for mget */
617 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
619 /* empty the cache to ensure misses (hence non-responses) */
620 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
622 keys_st
keys(key_count
);
624 oldalarm
= signal(SIGALRM
, fail
);
627 test_compare_got(MEMCACHED_SUCCESS
,
628 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
629 memcached_last_error_message(memc_clone
));
632 signal(SIGALRM
, oldalarm
);
634 memcached_return_t rc
;
636 char return_key
[MEMCACHED_MAX_KEY
];
637 size_t return_key_length
;
639 size_t return_value_length
;
640 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
641 &return_value_length
, &flags
, &rc
)))
643 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
645 test_compare(MEMCACHED_NOTFOUND
, rc
);
646 test_zero(return_value_length
);
647 test_zero(return_key_length
);
648 test_false(return_key
[0]);
649 test_false(return_value
);
651 memcached_free(memc_clone
);
657 test_return_t
user_supplied_bug21(memcached_st
*memc
)
659 test_skip(TEST_SUCCESS
, pre_binary(memc
));
661 /* should work as of r580 */
662 test_compare(TEST_SUCCESS
,
663 _user_supplied_bug21(memc
, 10));
665 /* should fail as of r580 */
666 test_compare(TEST_SUCCESS
,
667 _user_supplied_bug21(memc
, 1000));
672 test_return_t
comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st
*)
676 memcached_st
*memc
= &memc_
;
678 ASSERT_EQ(memc
, MEMCACHED_SUCCESS
);
679 test_compare(memc
, MEMCACHED_SUCCESS
);
681 ASSERT_NEQ(memc
, MEMCACHED_FAILURE
);
687 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
691 #ifdef HARD_MALLOC_TESTS
692 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
700 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
704 #ifdef HARD_MALLOC_TESTS
705 void *ret
= malloc(size
+ 8);
708 ret
= (void*)((caddr_t
)ret
+ 8);
711 void *ret
= malloc(size
);
716 memset(ret
, 0xff, size
);
723 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
725 #ifdef HARD_MALLOC_TESTS
726 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
727 void *nmem
= realloc(real_ptr
, size
+ 8);
732 ret
= (void*)((caddr_t
)nmem
+ 8);
738 return realloc(mem
, size
);
743 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
745 #ifdef HARD_MALLOC_TESTS
746 void *mem
= my_malloc(ptr
, nelem
* size
);
749 memset(mem
, 0, nelem
* size
);
755 return calloc(nelem
, size
);
759 #ifdef MEMCACHED_ENABLE_DEPRECATED
760 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
762 void *test_ptr
= NULL
;
765 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
766 cb_ptr
= *(void **)&malloc_cb
;
767 memcached_return_t rc
;
769 test_compare(MEMCACHED_SUCCESS
,
770 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
771 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
772 test_compare(MEMCACHED_SUCCESS
, rc
);
773 test_true(test_ptr
== cb_ptr
);
777 memcached_realloc_fn realloc_cb
=
778 (memcached_realloc_fn
)my_realloc
;
779 cb_ptr
= *(void **)&realloc_cb
;
780 memcached_return_t rc
;
782 test_compare(MEMCACHED_SUCCESS
,
783 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
784 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
785 test_compare(MEMCACHED_SUCCESS
, rc
);
786 test_true(test_ptr
== cb_ptr
);
790 memcached_free_fn free_cb
=
791 (memcached_free_fn
)my_free
;
792 cb_ptr
= *(void **)&free_cb
;
793 memcached_return_t rc
;
795 test_compare(MEMCACHED_SUCCESS
,
796 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
797 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
798 test_compare(MEMCACHED_SUCCESS
, rc
);
799 test_true(test_ptr
== cb_ptr
);
807 test_return_t
set_memory_alloc(memcached_st
*memc
)
809 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
810 memcached_set_memory_allocators(memc
, NULL
, my_free
,
811 my_realloc
, my_calloc
, NULL
));
813 test_compare(MEMCACHED_SUCCESS
,
814 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
815 my_realloc
, my_calloc
, NULL
));
817 memcached_malloc_fn mem_malloc
;
818 memcached_free_fn mem_free
;
819 memcached_realloc_fn mem_realloc
;
820 memcached_calloc_fn mem_calloc
;
821 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
822 &mem_realloc
, &mem_calloc
);
824 test_true(mem_malloc
== my_malloc
);
825 test_true(mem_realloc
== my_realloc
);
826 test_true(mem_calloc
== my_calloc
);
827 test_true(mem_free
== my_free
);
835 Test case adapted from John Gorman <johngorman2@gmail.com>
837 We are testing the error condition when we connect to a server via memcached_get()
838 but find that the server is not available.
840 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
847 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
849 // See if memcached is reachable.
850 char *value
= memcached_get(tl_memc_h
,
851 test_literal_param(__func__
),
856 test_true(memcached_failed(rc
));
858 memcached_free(tl_memc_h
);
864 Test case adapted from John Gorman <johngorman2@gmail.com>
866 We are testing the error condition when we connect to a server via memcached_get_by_key()
867 but find that the server is not available.
869 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
876 memcached_st
*tl_memc_h
= memcached_create(NULL
);
877 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
878 memcached_server_push(tl_memc_h
, servers
);
879 memcached_server_list_free(servers
);
881 // See if memcached is reachable.
882 char *value
= memcached_get_by_key(tl_memc_h
,
883 test_literal_param(__func__
), // Key
884 test_literal_param(__func__
), // Value
889 test_true(memcached_failed(rc
));
891 memcached_free(tl_memc_h
);
896 /* Test memcached_server_get_last_disconnect
897 * For a working server set, shall be NULL
898 * For a set of non existing server, shall not be NULL
900 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
902 memcached_return_t rc
;
903 const memcached_instance_st
* disconnected_server
;
905 /* With the working set of server */
906 const char *key
= "marmotte";
907 const char *value
= "milka";
909 memcached_reset_last_disconnected_server(memc
);
910 test_false(memc
->last_disconnected_server
);
911 rc
= memcached_set(memc
, key
, strlen(key
),
912 value
, strlen(value
),
913 (time_t)0, (uint32_t)0);
914 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
916 disconnected_server
= memcached_server_get_last_disconnect(memc
);
917 test_false(disconnected_server
);
919 /* With a non existing server */
921 memcached_server_st
*servers
;
923 const char *server_list
= "localhost:9";
925 servers
= memcached_servers_parse(server_list
);
927 mine
= memcached_create(NULL
);
928 rc
= memcached_server_push(mine
, servers
);
929 test_compare(MEMCACHED_SUCCESS
, rc
);
930 memcached_server_list_free(servers
);
933 rc
= memcached_set(mine
, key
, strlen(key
),
934 value
, strlen(value
),
935 (time_t)0, (uint32_t)0);
936 test_true(memcached_failed(rc
));
938 disconnected_server
= memcached_server_get_last_disconnect(mine
);
939 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
940 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
941 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
943 memcached_quit(mine
);
944 memcached_free(mine
);
949 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
951 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
954 test_compare(MEMCACHED_SUCCESS
,
955 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
957 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
960 // We will just use the error strings as our keys
961 uint32_t counter
= 100;
964 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
966 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
967 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
968 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
970 const memcached_instance_st
* disconnected_server
= memcached_server_get_last_disconnect(memc
);
971 test_true(disconnected_server
);
972 test_strcmp("localhost", memcached_server_name(disconnected_server
));
973 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
977 memcached_reset_last_disconnected_server(memc
);
982 memcached_free(memc
);
988 * This test ensures that the failure counter isn't incremented during
989 * normal termination of the memcached instance.
991 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
993 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
995 /* Ensure that we are connected to the server by setting a value */
996 memcached_return_t rc
= memcached_set(memc
,
997 test_literal_param(__func__
), // Key
998 test_literal_param(__func__
), // Value
999 time_t(0), uint32_t(0));
1000 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1003 const memcached_instance_st
* instance
= memcached_server_instance_by_position(memc
, 0);
1005 /* The test is to see that the memcached_quit doesn't increase the
1006 * the server failure conter, so let's ensure that it is zero
1007 * before sending quit
1009 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
1011 memcached_quit(memc
);
1013 /* Verify that it memcached_quit didn't increment the failure counter
1014 * Please note that this isn't bullet proof, because an error could
1017 test_zero(instance
->server_failure_counter
);
1019 memcached_free(memc
);
1021 return TEST_SUCCESS
;
1025 * This tests ensures expected disconnections (for some behavior changes
1026 * for instance) do not wrongly increase failure counter
1028 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
1030 /* Set value to force connection to the server */
1031 const char *key
= "marmotte";
1032 const char *value
= "milka";
1034 test_compare_hint(MEMCACHED_SUCCESS
,
1035 memcached_set(memc
, key
, strlen(key
),
1036 value
, strlen(value
),
1037 (time_t)0, (uint32_t)0),
1038 memcached_last_error_message(memc
));
1041 /* put failure limit to 1 */
1042 test_compare(MEMCACHED_SUCCESS
,
1043 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
1045 /* Put a retry timeout to effectively activate failure_limit effect */
1046 test_compare(MEMCACHED_SUCCESS
,
1047 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
1049 /* change behavior that triggers memcached_quit()*/
1050 test_compare(MEMCACHED_SUCCESS
,
1051 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
1054 /* Check if we still are connected */
1056 size_t string_length
;
1057 memcached_return rc
;
1058 char *string
= memcached_get(memc
, key
, strlen(key
),
1059 &string_length
, &flags
, &rc
);
1061 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1065 return TEST_SUCCESS
;
1069 test_return_t
regression_1021819_TEST(memcached_st
*original
)
1071 memcached_st
*memc
= memcached_clone(NULL
, original
);
1074 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 2000000), MEMCACHED_SUCCESS
);
1075 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 3000000), MEMCACHED_SUCCESS
);
1077 memcached_return_t rc
;
1080 test_literal_param(__func__
),
1083 test_compare(rc
, MEMCACHED_NOTFOUND
);
1085 memcached_free(memc
);
1087 return TEST_SUCCESS
;
1090 test_return_t
regression_bug_583031(memcached_st
*)
1092 memcached_st
*memc
= memcached_create(NULL
);
1094 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.251.4", 11211));
1096 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 3000);
1097 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
1098 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
1099 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
1100 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
1101 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
1103 memcached_return_t rc
;
1107 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
1111 test_compare(MEMCACHED_TIMEOUT
, memc
);
1113 memcached_free(memc
);
1115 return TEST_SUCCESS
;
1118 test_return_t
regression_bug_581030(memcached_st
*)
1121 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
1122 test_false(local_stat
);
1124 memcached_stat_free(NULL
, NULL
);
1127 return TEST_SUCCESS
;
1130 #define regression_bug_655423_COUNT 6000
1131 test_return_t
regression_bug_655423(memcached_st
*memc
)
1133 memcached_st
*clone
= memcached_clone(NULL
, memc
);
1134 memc
= NULL
; // Just to make sure it is not used
1139 return TEST_SKIPPED
;
1142 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
1143 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
1144 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
1145 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
1147 memset(payload
, int('x'), sizeof(payload
));
1149 keys_st
keys(regression_bug_655423_COUNT
);
1151 for (size_t x
= 0; x
< keys
.size(); x
++)
1153 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
1156 payload
, sizeof(payload
), 0, 0));
1159 for (size_t x
= 0; x
< keys
.size(); x
++)
1161 size_t value_length
;
1162 memcached_return_t rc
;
1163 char *value
= memcached_get(clone
,
1166 &value_length
, NULL
, &rc
);
1168 if (rc
== MEMCACHED_NOTFOUND
)
1171 test_zero(value_length
);
1175 test_compare(MEMCACHED_SUCCESS
, rc
);
1177 test_compare(100LLU, value_length
);
1181 test_compare(MEMCACHED_SUCCESS
,
1182 memcached_mget(clone
,
1183 keys
.keys_ptr(), keys
.lengths_ptr(),
1187 memcached_result_st
*result
= NULL
;
1188 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
1190 test_compare(size_t(100), memcached_result_length(result
));
1194 test_true(count
> 100); // If we don't get back atleast this, something is up
1196 memcached_free(clone
);
1198 return TEST_SUCCESS
;
1202 * Test that ensures that buffered set to not trigger problems during io_flush
1204 #define regression_bug_490520_COUNT 200480
1205 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
1207 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
1209 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
1210 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
1211 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
1212 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
1213 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
1215 /* First add all of the items.. */
1216 char blob
[3333] = {0};
1217 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
1220 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
1222 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
1223 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
1226 memcached_free(memc
);
1228 return TEST_SUCCESS
;
1231 test_return_t
regression_bug_1251482(memcached_st
*)
1233 test::Memc
memc("--server=localhost:5");
1235 memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 0);
1237 for (size_t x
= 0; x
< 5; ++x
)
1239 size_t value_length
;
1240 memcached_return_t rc
;
1241 char *value
= memcached_get(&memc
,
1242 test_literal_param(__func__
),
1243 &value_length
, NULL
, &rc
);
1246 test_compare(0LLU, value_length
);
1248 test_ne_compare(MEMCACHED_SUCCESS
, rc
);
1250 test_compare(MEMCACHED_CONNECTION_FAILURE
, rc
);
1254 return TEST_SUCCESS
;
1257 test_return_t
regression_1009493_TEST(memcached_st
*)
1259 memcached_st
* memc
= memcached_create(NULL
);
1261 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, true));
1263 memcached_st
* clone
= memcached_clone(NULL
, memc
);
1266 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
),
1267 memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
1269 memcached_free(memc
);
1270 memcached_free(clone
);
1272 return TEST_SUCCESS
;
1275 test_return_t
regression_994772_TEST(memcached_st
* memc
)
1277 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
1279 test_compare(MEMCACHED_SUCCESS
,
1281 test_literal_param(__func__
), // Key
1282 test_literal_param(__func__
), // Value
1283 time_t(0), uint32_t(0)));
1285 const char *keys
[] = { __func__
};
1286 size_t key_length
[]= { strlen(__func__
) };
1287 test_compare(MEMCACHED_SUCCESS
,
1288 memcached_mget(memc
, keys
, key_length
, 1));
1290 memcached_return_t rc
;
1291 memcached_result_st
*results
= memcached_fetch_result(memc
, NULL
, &rc
);
1293 test_compare(MEMCACHED_SUCCESS
, rc
);
1295 test_strcmp(__func__
, memcached_result_value(results
));
1296 uint64_t cas_value
= memcached_result_cas(results
);
1297 test_true(cas_value
);
1299 char* take_value
= memcached_result_take_value(results
);
1300 test_strcmp(__func__
, take_value
);
1303 memcached_result_free(results
);
1305 // Bad cas value, sanity check
1306 test_true(cas_value
!= 9999);
1307 test_compare(MEMCACHED_END
,
1309 test_literal_param(__func__
), // Key
1310 test_literal_param(__FILE__
), // Value
1311 time_t(0), uint32_t(0), 9999));
1313 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
1314 "different", strlen("different"), // Key
1315 test_literal_param(__FILE__
), // Value
1316 time_t(0), uint32_t(0)));
1318 return TEST_SUCCESS
;
1321 test_return_t
regression_bug_854604(memcached_st
*)
1325 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
1327 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
1329 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
1330 test_compare(buffer
[0], 0);
1332 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
1333 test_true(strlen(buffer
));
1335 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
1336 test_true(strlen(buffer
));
1338 return TEST_SUCCESS
;
1341 static void die_message(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
1343 fprintf(stderr
, "Iteration #%u: ", it
);
1345 if (error
== MEMCACHED_ERRNO
)
1347 fprintf(stderr
, "system error %d from %s: %s\n",
1348 errno
, what
, strerror(errno
));
1352 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
1353 memcached_strerror(mc
, error
));