projects / m6w6 / libmemcached / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
testing
[m6w6/libmemcached] / tests / libmemcached-1.0 / mem_functions.cc
1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
2 *
3 * Libmemcached library
4 *
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
10 * met:
11 *
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
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
18 * distribution.
19 *
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
22 * written permission.
23 *
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.
35 *
36 */
37
38 #include "mem_config.h"
39 #include "libtest/test.hpp"
40
41 #if defined(HAVE_LIBUUID) && HAVE_LIBUUID
42 # include <uuid/uuid.h>
43 #endif
44
45 /*
46 Test cases
47 */
48
49 #include "libmemcached-1.0/memcached.h"
50 #include "libmemcached/is.h"
51 #include "libmemcached/server_instance.h"
52
53 #include "libhashkit-1.0/hashkit.h"
54
55 #include "libtest/memcached.hpp"
56
57 #include <cerrno>
58 #include <memory>
59 #include <pthread.h>
60 #include <semaphore.h>
61 #include <signal.h>
62 #include <sys/stat.h>
63 #include <sys/time.h>
64 #include <sys/types.h>
65 #include <unistd.h>
66
67 #include <iostream>
68
69 #include "libtest/server.h"
70
71 #include "bin/generator.h"
72
73 #define SMALL_STRING_LEN 1024
74
75 #include "libtest/test.hpp"
76
77 using namespace libtest;
78
79 #include "libmemcachedutil-1.0/util.h"
80
81 #include "tests/hash_results.h"
82
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"
90
91 #define UUID_STRING_MAXLENGTH 36
92
93 #include "tests/keys.hpp"
94
95 #include "libmemcached/instance.hpp"
96
97
98 test_return_t mget_end(memcached_st *memc)
99 {
100 const char *keys[]= { "foo", "foo2" };
101 size_t lengths[]= { 3, 4 };
102 const char *values[]= { "fjord", "41" };
103
104 // Set foo and foo2
105 for (size_t x= 0; x < test_array_length(keys); x++)
106 {
107 test_compare(MEMCACHED_SUCCESS,
108 memcached_set(memc,
109 keys[x], lengths[x],
110 values[x], strlen(values[x]),
111 time_t(0), uint32_t(0)));
112 }
113
114 char *string;
115 size_t string_length;
116 uint32_t flags;
117
118 // retrieve both via mget
119 test_compare(MEMCACHED_SUCCESS,
120 memcached_mget(memc,
121 keys, lengths,
122 test_array_length(keys)));
123
124 char key[MEMCACHED_MAX_KEY];
125 size_t key_length;
126 memcached_return_t rc;
127
128 // this should get both
129 for (size_t x= 0; x < test_array_length(keys); x++)
130 {
131 string= memcached_fetch(memc, key, &key_length, &string_length,
132 &flags, &rc);
133 test_compare(MEMCACHED_SUCCESS, rc);
134 int val = 0;
135 if (key_length == 4)
136 {
137 val= 1;
138 }
139
140 test_compare(string_length, strlen(values[val]));
141 test_true(strncmp(values[val], string, string_length) == 0);
142 free(string);
143 }
144
145 // this should indicate end
146 string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
147 test_compare(MEMCACHED_END, rc);
148 test_null(string);
149
150 // now get just one
151 test_compare(MEMCACHED_SUCCESS,
152 memcached_mget(memc, keys, lengths, 1));
153
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);
160 free(string);
161
162 // this should indicate end
163 string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
164 test_compare(MEMCACHED_END, rc);
165 test_null(string);
166
167 return TEST_SUCCESS;
168 }
169
170 test_return_t mget_result_test(memcached_st *memc)
171 {
172 const char *keys[]= {"fudge", "son", "food"};
173 size_t key_length[]= {5, 3, 4};
174
175 memcached_result_st results_obj;
176 memcached_result_st *results= memcached_result_create(memc, &results_obj);
177 test_true(results);
178 test_true(&results_obj == results);
179
180 /* We need to empty the server before continueing test */
181 test_compare(MEMCACHED_SUCCESS,
182 memcached_flush(memc, 0));
183
184 test_compare(MEMCACHED_SUCCESS,
185 memcached_mget(memc, keys, key_length, 3));
186
187 memcached_return_t rc;
188 while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
189 {
190 test_true(results);
191 }
192
193 while ((results= memcached_fetch_result(memc, &results_obj, &rc))) { test_true(false); /* We should never see a value returned */ };
194 test_false(results);
195 test_compare(MEMCACHED_NOTFOUND, rc);
196
197 for (uint32_t x= 0; x < 3; x++)
198 {
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);
203 }
204
205 test_compare(MEMCACHED_SUCCESS,
206 memcached_mget(memc, keys, key_length, 3));
207
208 while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
209 {
210 test_true(results);
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));
217 }
218
219 memcached_result_free(&results_obj);
220
221 return TEST_SUCCESS;
222 }
223
224 test_return_t mget_result_alloc_test(memcached_st *memc)
225 {
226 const char *keys[]= {"fudge", "son", "food"};
227 size_t key_length[]= {5, 3, 4};
228
229 memcached_result_st *results;
230
231 /* We need to empty the server before continueing test */
232 test_compare(MEMCACHED_SUCCESS,
233 memcached_flush(memc, 0));
234
235 test_compare(MEMCACHED_SUCCESS,
236 memcached_mget(memc, keys, key_length, 3));
237
238 memcached_return_t rc;
239 while ((results= memcached_fetch_result(memc, NULL, &rc)))
240 {
241 test_true(results);
242 }
243 test_false(results);
244 test_compare(MEMCACHED_NOTFOUND, rc);
245
246 for (uint32_t x= 0; x < 3; x++)
247 {
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);
252 }
253
254 test_compare(MEMCACHED_SUCCESS,
255 memcached_mget(memc, keys, key_length, 3));
256
257 uint32_t x= 0;
258 while ((results= memcached_fetch_result(memc, NULL, &rc)))
259 {
260 test_true(results);
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);
267 x++;
268 }
269
270 return TEST_SUCCESS;
271 }
272
273 test_return_t mget_result_function(memcached_st *memc)
274 {
275 const char *keys[]= {"fudge", "son", "food"};
276 size_t key_length[]= {5, 3, 4};
277 size_t counter;
278 memcached_execute_fn callbacks[1];
279
280 for (uint32_t x= 0; x < 3; x++)
281 {
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)));
286 }
287 test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
288 memcached_quit(memc);
289
290 test_compare(MEMCACHED_SUCCESS,
291 memcached_mget(memc, keys, key_length, 3));
292
293 callbacks[0]= &callback_counter;
294 counter= 0;
295
296 test_compare(MEMCACHED_SUCCESS,
297 memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
298
299 test_compare(size_t(3), counter);
300
301 return TEST_SUCCESS;
302 }
303
304 test_return_t mget_test(memcached_st *memc)
305 {
306 const char *keys[]= {"fudge", "son", "food"};
307 size_t key_length[]= {5, 3, 4};
308
309 char return_key[MEMCACHED_MAX_KEY];
310 size_t return_key_length;
311 char *return_value;
312 size_t return_value_length;
313
314 test_compare(MEMCACHED_SUCCESS,
315 memcached_mget(memc, keys, key_length, 3));
316
317 uint32_t flags;
318 memcached_return_t rc;
319 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
320 &return_value_length, &flags, &rc)))
321 {
322 test_true(return_value);
323 }
324 test_false(return_value);
325 test_zero(return_value_length);
326 test_compare(MEMCACHED_NOTFOUND, rc);
327
328 for (uint32_t x= 0; x < 3; x++)
329 {
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);
334 }
335 test_compare(MEMCACHED_SUCCESS,
336 memcached_mget(memc, keys, key_length, 3));
337
338 uint32_t x= 0;
339 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
340 &return_value_length, &flags, &rc)))
341 {
342 test_true(return_value);
343 test_compare(MEMCACHED_SUCCESS, rc);
344 if (not memc->_namespace)
345 {
346 test_compare(return_key_length, return_value_length);
347 test_memcmp(return_value, return_key, return_value_length);
348 }
349 free(return_value);
350 x++;
351 }
352
353 return TEST_SUCCESS;
354 }
355
356 test_return_t mget_execute(memcached_st *original_memc)
357 {
358 test_skip(true, memcached_behavior_get(original_memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
359
360 memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL");
361 test_true(memc);
362
363 keys_st keys(20480);
364
365 /* First add all of the items.. */
366 char blob[1024] = {0};
367
368 for (size_t x= 0; x < keys.size(); ++x)
369 {
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),
373 blob, sizeof(blob),
374 0, 0);
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));
377 }
378
379 /* Try to get all of them with a large multiget */
380 size_t counter= 0;
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));
386
387 {
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));
392
393 /* Verify that we got all of the items */
394 test_compare(keys.size(), counter);
395 }
396
397 memcached_free(memc);
398
399 return TEST_SUCCESS;
400 }
401
402 test_return_t MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST(memcached_st *original_memc)
403 {
404 test_skip(true, memcached_behavior_get(original_memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
405
406 memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL");
407 test_true(memc);
408
409 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH, 8));
410
411 keys_st keys(20480);
412
413 /* First add all of the items.. */
414 char blob[1024] = {0};
415
416 for (size_t x= 0; x < keys.size(); ++x)
417 {
418 uint64_t query_id= memcached_query_id(memc);
419 memcached_return_t rc= memcached_add(memc,
420 keys.key_at(x), keys.length_at(x),
421 blob, sizeof(blob),
422 0, 0);
423 test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
424 test_compare(query_id +1, memcached_query_id(memc));
425 }
426
427 /* Try to get all of them with a large multiget */
428 size_t counter= 0;
429 memcached_execute_fn callbacks[]= { &callback_counter };
430 test_compare(MEMCACHED_SUCCESS,
431 memcached_mget_execute(memc,
432 keys.keys_ptr(), keys.lengths_ptr(),
433 keys.size(), callbacks, &counter, 1));
434
435 {
436 uint64_t query_id= memcached_query_id(memc);
437 test_compare(MEMCACHED_SUCCESS,
438 memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
439 test_compare(query_id, memcached_query_id(memc));
440
441 /* Verify that we got all of the items */
442 test_compare(keys.size(), counter);
443 }
444
445 memcached_free(memc);
446
447 return TEST_SUCCESS;
448 }
449
450 test_return_t memcached_fetch_result_NOT_FOUND(memcached_st *memc)
451 {
452 memcached_return_t rc;
453
454 const char *key= "not_found";
455 size_t key_length= test_literal_param_size("not_found");
456
457 test_compare(MEMCACHED_SUCCESS,
458 memcached_mget(memc, &key, &key_length, 1));
459
460 memcached_result_st *result= memcached_fetch_result(memc, NULL, &rc);
461 test_null(result);
462 test_compare(MEMCACHED_NOTFOUND, rc);
463
464 memcached_result_free(result);
465
466 return TEST_SUCCESS;
467 }
468
469 /*
470 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
471 */
472 test_return_t user_supplied_bug12(memcached_st *memc)
473 {
474 memcached_return_t rc;
475 uint32_t flags;
476 size_t value_length;
477 char *value;
478 uint64_t number_value;
479
480 value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
481 &value_length, &flags, &rc);
482 test_null(value);
483 test_compare(MEMCACHED_NOTFOUND, rc);
484
485 rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
486 1, &number_value);
487 test_null(value);
488 /* The binary protocol will set the key if it doesn't exist */
489 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
490 {
491 test_compare(MEMCACHED_SUCCESS, rc);
492 }
493 else
494 {
495 test_compare(MEMCACHED_NOTFOUND, rc);
496 }
497
498 test_compare(MEMCACHED_SUCCESS,
499 memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
500
501 value= memcached_get(memc, "autoincrement", strlen("autoincrement"), &value_length, &flags, &rc);
502 test_true(value);
503 free(value);
504
505 test_compare(MEMCACHED_SUCCESS,
506 memcached_increment(memc, "autoincrement", strlen("autoincrement"), 1, &number_value));
507 test_compare(2UL, number_value);
508
509 return TEST_SUCCESS;
510 }
511
512 /*
513 Bug found where command total one more than MEMCACHED_MAX_BUFFER
514 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
515 */
516 test_return_t user_supplied_bug13(memcached_st *memc)
517 {
518 char key[] = "key34567890";
519
520 char commandFirst[]= "set key34567890 0 0 ";
521 char commandLast[] = " \r\n"; /* first line of command sent to server */
522 size_t commandLength;
523
524 commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
525
526 size_t overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
527
528 for (size_t testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
529 {
530 char *overflow= new (std::nothrow) char[testSize];
531 test_true(overflow);
532
533 memset(overflow, 'x', testSize);
534 test_compare(MEMCACHED_SUCCESS,
535 memcached_set(memc, key, strlen(key),
536 overflow, testSize, 0, 0));
537 delete [] overflow;
538 }
539
540 return TEST_SUCCESS;
541 }
542
543
544 /*
545 Test values of many different sizes
546 Bug found where command total one more than MEMCACHED_MAX_BUFFER
547 set key34567890 0 0 8169 \r\n
548 is sent followed by buffer of size 8169, followed by 8169
549 */
550 test_return_t user_supplied_bug14(memcached_st *memc)
551 {
552 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);
553
554 libtest::vchar_t value;
555 value.reserve(18000);
556 for (ptrdiff_t x= 0; x < 18000; x++)
557 {
558 value.push_back((char) (x % 127));
559 }
560
561 for (size_t current_length= 1; current_length < value.size(); current_length++)
562 {
563 memcached_return_t rc= memcached_set(memc, test_literal_param("foo"),
564 &value[0], current_length,
565 (time_t)0, (uint32_t)0);
566 ASSERT_TRUE_(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, "Instead got %s", memcached_strerror(NULL, rc));
567
568 size_t string_length;
569 uint32_t flags;
570 char *string= memcached_get(memc, test_literal_param("foo"),
571 &string_length, &flags, &rc);
572
573 test_compare(MEMCACHED_SUCCESS, rc);
574 test_compare(string_length, current_length);
575 char buffer[1024];
576 snprintf(buffer, sizeof(buffer), "%u", uint32_t(string_length));
577 test_memcmp(string, &value[0], string_length);
578
579 free(string);
580 }
581
582 return TEST_SUCCESS;
583 }
584
585 /*
586 Look for zero length value problems
587 */
588 test_return_t user_supplied_bug15(memcached_st *memc)
589 {
590 for (uint32_t x= 0; x < 2; x++)
591 {
592 memcached_return_t rc= memcached_set(memc, test_literal_param("mykey"),
593 NULL, 0,
594 (time_t)0, (uint32_t)0);
595
596 test_compare(MEMCACHED_SUCCESS, rc);
597
598 size_t length;
599 uint32_t flags;
600 char *value= memcached_get(memc, test_literal_param("mykey"),
601 &length, &flags, &rc);
602
603 test_compare(MEMCACHED_SUCCESS, rc);
604 test_false(value);
605 test_zero(length);
606 test_zero(flags);
607
608 value= memcached_get(memc, test_literal_param("mykey"),
609 &length, &flags, &rc);
610
611 test_compare(MEMCACHED_SUCCESS, rc);
612 test_null(value);
613 test_zero(length);
614 test_zero(flags);
615 }
616
617 return TEST_SUCCESS;
618 }
619
620 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
621 test_return_t user_supplied_bug16(memcached_st *memc)
622 {
623 test_compare(MEMCACHED_SUCCESS, memcached_set(memc, test_literal_param("mykey"),
624 NULL, 0,
625 (time_t)0, UINT32_MAX));
626
627
628 size_t length;
629 uint32_t flags;
630 memcached_return_t rc;
631 char *value= memcached_get(memc, test_literal_param("mykey"),
632 &length, &flags, &rc);
633
634 test_compare(MEMCACHED_SUCCESS, rc);
635 test_null(value);
636 test_zero(length);
637 test_compare(flags, UINT32_MAX);
638
639 return TEST_SUCCESS;
640 }
641
642 #if !defined(__sun) && !defined(__OpenBSD__)
643 /* Check the validity of chinese key*/
644 test_return_t user_supplied_bug17(memcached_st *memc)
645 {
646 const char *key= "豆瓣";
647 const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
648 memcached_return_t rc= memcached_set(memc, key, strlen(key),
649 value, strlen(value),
650 (time_t)0, 0);
651
652 test_compare(MEMCACHED_SUCCESS, rc);
653
654 size_t length;
655 uint32_t flags;
656 char *value2= memcached_get(memc, key, strlen(key),
657 &length, &flags, &rc);
658
659 test_compare(length, strlen(value));
660 test_compare(MEMCACHED_SUCCESS, rc);
661 test_memcmp(value, value2, length);
662 free(value2);
663
664 return TEST_SUCCESS;
665 }
666 #endif
667
668 /*
669 From Andrei on IRC
670 */
671
672 test_return_t user_supplied_bug19(memcached_st *)
673 {
674 memcached_return_t res;
675
676 memcached_st *memc= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
677
678 const memcached_instance_st * server= memcached_server_by_key(memc, "a", 1, &res);
679 test_true(server);
680
681 memcached_free(memc);
682
683 return TEST_SUCCESS;
684 }
685
686 /* CAS test from Andei */
687 test_return_t user_supplied_bug20(memcached_st *memc)
688 {
689 const char *key= "abc";
690 size_t key_len= strlen("abc");
691
692 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));
693
694 test_compare(MEMCACHED_SUCCESS,
695 memcached_set(memc,
696 test_literal_param("abc"),
697 test_literal_param("foobar"),
698 (time_t)0, (uint32_t)0));
699
700 test_compare(MEMCACHED_SUCCESS,
701 memcached_mget(memc, &key, &key_len, 1));
702
703 memcached_result_st result_obj;
704 memcached_result_st *result= memcached_result_create(memc, &result_obj);
705 test_true(result);
706
707 memcached_result_create(memc, &result_obj);
708 memcached_return_t status;
709 result= memcached_fetch_result(memc, &result_obj, &status);
710
711 test_true(result);
712 test_compare(MEMCACHED_SUCCESS, status);
713
714 memcached_result_free(result);
715
716 return TEST_SUCCESS;
717 }
718
719 /* Large mget() of missing keys with binary proto
720 *
721 * If many binary quiet commands (such as getq's in an mget) fill the output
722 * buffer and the server chooses not to respond, memcached_flush hangs. See
723 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
724 */
725
726 /* sighandler_t function that always asserts false */
727 static __attribute__((noreturn)) void fail(int)
728 {
729 fatal_assert(0);
730 }
731
732
733 test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)
734 {
735 #ifdef WIN32
736 (void)memc;
737 (void)key_count;
738 return TEST_SKIPPED;
739 #else
740 void (*oldalarm)(int);
741
742 memcached_st *memc_clone= memcached_clone(NULL, memc);
743 test_true(memc_clone);
744
745 /* only binproto uses getq for mget */
746 test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true));
747
748 /* empty the cache to ensure misses (hence non-responses) */
749 test_compare(MEMCACHED_SUCCESS, memcached_flush(memc_clone, 0));
750
751 keys_st keys(key_count);
752
753 oldalarm= signal(SIGALRM, fail);
754 alarm(5);
755
756 test_compare_got(MEMCACHED_SUCCESS,
757 memcached_mget(memc_clone, keys.keys_ptr(), keys.lengths_ptr(), keys.size()),
758 memcached_last_error_message(memc_clone));
759
760 alarm(0);
761 signal(SIGALRM, oldalarm);
762
763 memcached_return_t rc;
764 uint32_t flags;
765 char return_key[MEMCACHED_MAX_KEY];
766 size_t return_key_length;
767 char *return_value;
768 size_t return_value_length;
769 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
770 &return_value_length, &flags, &rc)))
771 {
772 test_false(return_value); // There are no keys to fetch, so the value should never be returned
773 }
774 test_compare(MEMCACHED_NOTFOUND, rc);
775 test_zero(return_value_length);
776 test_zero(return_key_length);
777 test_false(return_key[0]);
778 test_false(return_value);
779
780 memcached_free(memc_clone);
781
782 return TEST_SUCCESS;
783 #endif
784 }
785
786 test_return_t user_supplied_bug21(memcached_st *memc)
787 {
788 test_skip(TEST_SUCCESS, pre_binary(memc));
789
790 /* should work as of r580 */
791 test_compare(TEST_SUCCESS,
792 _user_supplied_bug21(memc, 10));
793
794 /* should fail as of r580 */
795 test_compare(TEST_SUCCESS,
796 _user_supplied_bug21(memc, 1000));
797
798 return TEST_SUCCESS;
799 }
800
801 test_return_t comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st *)
802 {
803 test::Memc memc_;
804
805 memcached_st *memc= &memc_;
806
807 ASSERT_EQ(memc, MEMCACHED_SUCCESS);
808 test_compare(memc, MEMCACHED_SUCCESS);
809
810 ASSERT_NEQ(memc, MEMCACHED_FAILURE);
811
812 return TEST_SUCCESS;
813 }
814
815 test_return_t result_static(memcached_st *memc)
816 {
817 memcached_result_st result;
818 memcached_result_st *result_ptr= memcached_result_create(memc, &result);
819 test_false(result.options.is_allocated);
820 test_true(memcached_is_initialized(&result));
821 test_true(result_ptr);
822 test_true(result_ptr == &result);
823
824 memcached_result_free(&result);
825
826 test_false(result.options.is_allocated);
827 test_false(memcached_is_initialized(&result));
828
829 return TEST_SUCCESS;
830 }
831
832 test_return_t result_alloc(memcached_st *memc)
833 {
834 memcached_result_st *result_ptr= memcached_result_create(memc, NULL);
835 test_true(result_ptr);
836 test_true(result_ptr->options.is_allocated);
837 test_true(memcached_is_initialized(result_ptr));
838 memcached_result_free(result_ptr);
839
840 return TEST_SUCCESS;
841 }
842
843
844 static void my_free(const memcached_st *ptr, void *mem, void *context)
845 {
846 (void)context;
847 (void)ptr;
848 #ifdef HARD_MALLOC_TESTS
849 void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8);
850 free(real_ptr);
851 #else
852 free(mem);
853 #endif
854 }
855
856
857 static void *my_malloc(const memcached_st *ptr, const size_t size, void *context)
858 {
859 (void)context;
860 (void)ptr;
861 #ifdef HARD_MALLOC_TESTS
862 void *ret= malloc(size + 8);
863 if (ret != NULL)
864 {
865 ret= (void*)((caddr_t)ret + 8);
866 }
867 #else
868 void *ret= malloc(size);
869 #endif
870
871 if (ret != NULL)
872 {
873 memset(ret, 0xff, size);
874 }
875
876 return ret;
877 }
878
879
880 static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *)
881 {
882 #ifdef HARD_MALLOC_TESTS
883 void *real_ptr= (mem == NULL) ? NULL : (void*)((caddr_t)mem - 8);
884 void *nmem= realloc(real_ptr, size + 8);
885
886 void *ret= NULL;
887 if (nmem != NULL)
888 {
889 ret= (void*)((caddr_t)nmem + 8);
890 }
891
892 return ret;
893 #else
894 (void)ptr;
895 return realloc(mem, size);
896 #endif
897 }
898
899
900 static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *)
901 {
902 #ifdef HARD_MALLOC_TESTS
903 void *mem= my_malloc(ptr, nelem * size);
904 if (mem)
905 {
906 memset(mem, 0, nelem * size);
907 }
908
909 return mem;
910 #else
911 (void)ptr;
912 return calloc(nelem, size);
913 #endif
914 }
915
916 #ifdef MEMCACHED_ENABLE_DEPRECATED
917 test_return_t deprecated_set_memory_alloc(memcached_st *memc)
918 {
919 void *test_ptr= NULL;
920 void *cb_ptr= NULL;
921 {
922 memcached_malloc_fn malloc_cb= (memcached_malloc_fn)my_malloc;
923 cb_ptr= *(void **)&malloc_cb;
924 memcached_return_t rc;
925
926 test_compare(MEMCACHED_SUCCESS,
927 memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, cb_ptr));
928 test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
929 test_compare(MEMCACHED_SUCCESS, rc);
930 test_true(test_ptr == cb_ptr);
931 }
932
933 {
934 memcached_realloc_fn realloc_cb=
935 (memcached_realloc_fn)my_realloc;
936 cb_ptr= *(void **)&realloc_cb;
937 memcached_return_t rc;
938
939 test_compare(MEMCACHED_SUCCESS,
940 memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, cb_ptr));
941 test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
942 test_compare(MEMCACHED_SUCCESS, rc);
943 test_true(test_ptr == cb_ptr);
944 }
945
946 {
947 memcached_free_fn free_cb=
948 (memcached_free_fn)my_free;
949 cb_ptr= *(void **)&free_cb;
950 memcached_return_t rc;
951
952 test_compare(MEMCACHED_SUCCESS,
953 memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, cb_ptr));
954 test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
955 test_compare(MEMCACHED_SUCCESS, rc);
956 test_true(test_ptr == cb_ptr);
957 }
958
959 return TEST_SUCCESS;
960 }
961 #endif
962
963
964 test_return_t set_memory_alloc(memcached_st *memc)
965 {
966 test_compare(MEMCACHED_INVALID_ARGUMENTS,
967 memcached_set_memory_allocators(memc, NULL, my_free,
968 my_realloc, my_calloc, NULL));
969
970 test_compare(MEMCACHED_SUCCESS,
971 memcached_set_memory_allocators(memc, my_malloc, my_free,
972 my_realloc, my_calloc, NULL));
973
974 memcached_malloc_fn mem_malloc;
975 memcached_free_fn mem_free;
976 memcached_realloc_fn mem_realloc;
977 memcached_calloc_fn mem_calloc;
978 memcached_get_memory_allocators(memc, &mem_malloc, &mem_free,
979 &mem_realloc, &mem_calloc);
980
981 test_true(mem_malloc == my_malloc);
982 test_true(mem_realloc == my_realloc);
983 test_true(mem_calloc == my_calloc);
984 test_true(mem_free == my_free);
985
986 return TEST_SUCCESS;
987 }
988
989 test_return_t MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st *memc)
990 {
991 const uint64_t timeout= 100; // Not using, just checking that it sets
992
993 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
994
995 test_compare(timeout, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT));
996
997 return TEST_SUCCESS;
998 }
999
1000 test_return_t analyzer_test(memcached_st *memc)
1001 {
1002 memcached_analysis_st *report;
1003 memcached_return_t rc;
1004
1005 memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
1006 test_compare(MEMCACHED_SUCCESS, rc);
1007 test_true(memc_stat);
1008
1009 report= memcached_analyze(memc, memc_stat, &rc);
1010 test_compare(MEMCACHED_SUCCESS, rc);
1011 test_true(report);
1012
1013 free(report);
1014 memcached_stat_free(NULL, memc_stat);
1015
1016 return TEST_SUCCESS;
1017 }
1018
1019 test_return_t hsieh_avaibility_test (memcached_st *memc)
1020 {
1021 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH));
1022
1023 test_compare(MEMCACHED_SUCCESS,
1024 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
1025 (uint64_t)MEMCACHED_HASH_HSIEH));
1026
1027 return TEST_SUCCESS;
1028 }
1029
1030 test_return_t murmur_avaibility_test (memcached_st *memc)
1031 {
1032 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR));
1033
1034 test_compare(MEMCACHED_SUCCESS,
1035 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR));
1036
1037 return TEST_SUCCESS;
1038 }
1039
1040 /*
1041 Test case adapted from John Gorman <johngorman2@gmail.com>
1042
1043 We are testing the error condition when we connect to a server via memcached_get()
1044 but find that the server is not available.
1045 */
1046 test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *)
1047 {
1048 size_t len;
1049 uint32_t flags;
1050 memcached_return rc;
1051
1052 // Create a handle.
1053 memcached_st *tl_memc_h= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
1054
1055 // See if memcached is reachable.
1056 char *value= memcached_get(tl_memc_h,
1057 test_literal_param(__func__),
1058 &len, &flags, &rc);
1059
1060 test_false(value);
1061 test_zero(len);
1062 test_true(memcached_failed(rc));
1063
1064 memcached_free(tl_memc_h);
1065
1066 return TEST_SUCCESS;
1067 }
1068
1069 /*
1070 We connect to a server which exists, but search for a key that does not exist.
1071 */
1072 test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc)
1073 {
1074 size_t len;
1075 uint32_t flags;
1076 memcached_return rc;
1077
1078 // See if memcached is reachable.
1079 char *value= memcached_get(memc,
1080 test_literal_param(__func__),
1081 &len, &flags, &rc);
1082
1083 test_false(value);
1084 test_zero(len);
1085 test_compare(MEMCACHED_NOTFOUND, rc);
1086
1087 return TEST_SUCCESS;
1088 }
1089
1090 /*
1091 Test case adapted from John Gorman <johngorman2@gmail.com>
1092
1093 We are testing the error condition when we connect to a server via memcached_get_by_key()
1094 but find that the server is not available.
1095 */
1096 test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *)
1097 {
1098 size_t len;
1099 uint32_t flags;
1100 memcached_return rc;
1101
1102 // Create a handle.
1103 memcached_st *tl_memc_h= memcached_create(NULL);
1104 memcached_server_st *servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
1105 memcached_server_push(tl_memc_h, servers);
1106 memcached_server_list_free(servers);
1107
1108 // See if memcached is reachable.
1109 char *value= memcached_get_by_key(tl_memc_h,
1110 test_literal_param(__func__), // Key
1111 test_literal_param(__func__), // Value
1112 &len, &flags, &rc);
1113
1114 test_false(value);
1115 test_zero(len);
1116 test_true(memcached_failed(rc));
1117
1118 memcached_free(tl_memc_h);
1119
1120 return TEST_SUCCESS;
1121 }
1122
1123 /*
1124 We connect to a server which exists, but search for a key that does not exist.
1125 */
1126 test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc)
1127 {
1128 size_t len;
1129 uint32_t flags;
1130 memcached_return rc;
1131
1132 // See if memcached is reachable.
1133 char *value= memcached_get_by_key(memc,
1134 test_literal_param(__func__), // Key
1135 test_literal_param(__func__), // Value
1136 &len, &flags, &rc);
1137
1138 test_false(value);
1139 test_zero(len);
1140 test_compare(MEMCACHED_NOTFOUND, rc);
1141
1142 return TEST_SUCCESS;
1143 }
1144
1145 test_return_t regression_bug_421108(memcached_st *memc)
1146 {
1147 memcached_return_t rc;
1148 memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
1149 test_compare(MEMCACHED_SUCCESS, rc);
1150
1151 char *bytes_str= memcached_stat_get_value(memc, memc_stat, "bytes", &rc);
1152 test_compare(MEMCACHED_SUCCESS, rc);
1153 test_true(bytes_str);
1154 char *bytes_read_str= memcached_stat_get_value(memc, memc_stat,
1155 "bytes_read", &rc);
1156 test_compare(MEMCACHED_SUCCESS, rc);
1157 test_true(bytes_read_str);
1158
1159 char *bytes_written_str= memcached_stat_get_value(memc, memc_stat,
1160 "bytes_written", &rc);
1161 test_compare(MEMCACHED_SUCCESS, rc);
1162 test_true(bytes_written_str);
1163
1164 unsigned long long bytes= strtoull(bytes_str, 0, 10);
1165 unsigned long long bytes_read= strtoull(bytes_read_str, 0, 10);
1166 unsigned long long bytes_written= strtoull(bytes_written_str, 0, 10);
1167
1168 test_true(bytes != bytes_read);
1169 test_true(bytes != bytes_written);
1170
1171 /* Release allocated resources */
1172 free(bytes_str);
1173 free(bytes_read_str);
1174 free(bytes_written_str);
1175 memcached_stat_free(NULL, memc_stat);
1176
1177 return TEST_SUCCESS;
1178 }
1179
1180
1181 /* Test memcached_server_get_last_disconnect
1182 * For a working server set, shall be NULL
1183 * For a set of non existing server, shall not be NULL
1184 */
1185 test_return_t test_get_last_disconnect(memcached_st *memc)
1186 {
1187 memcached_return_t rc;
1188 const memcached_instance_st * disconnected_server;
1189
1190 /* With the working set of server */
1191 const char *key= "marmotte";
1192 const char *value= "milka";
1193
1194 memcached_reset_last_disconnected_server(memc);
1195 test_false(memc->last_disconnected_server);
1196 rc= memcached_set(memc, key, strlen(key),
1197 value, strlen(value),
1198 (time_t)0, (uint32_t)0);
1199 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1200
1201 disconnected_server = memcached_server_get_last_disconnect(memc);
1202 test_false(disconnected_server);
1203
1204 /* With a non existing server */
1205 memcached_st *mine;
1206 memcached_server_st *servers;
1207
1208 const char *server_list= "localhost:9";
1209
1210 servers= memcached_servers_parse(server_list);
1211 test_true(servers);
1212 mine= memcached_create(NULL);
1213 rc= memcached_server_push(mine, servers);
1214 test_compare(MEMCACHED_SUCCESS, rc);
1215 memcached_server_list_free(servers);
1216 test_true(mine);
1217
1218 rc= memcached_set(mine, key, strlen(key),
1219 value, strlen(value),
1220 (time_t)0, (uint32_t)0);
1221 test_true(memcached_failed(rc));
1222
1223 disconnected_server= memcached_server_get_last_disconnect(mine);
1224 test_true_got(disconnected_server, memcached_strerror(mine, rc));
1225 test_compare(in_port_t(9), memcached_server_port(disconnected_server));
1226 test_false(strncmp(memcached_server_name(disconnected_server),"localhost",9));
1227
1228 memcached_quit(mine);
1229 memcached_free(mine);
1230
1231 return TEST_SUCCESS;
1232 }
1233
1234 test_return_t test_multiple_get_last_disconnect(memcached_st *)
1235 {
1236 const char *server_string= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
1237 char buffer[BUFSIZ];
1238
1239 test_compare(MEMCACHED_SUCCESS,
1240 libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)));
1241
1242 memcached_st *memc= memcached(server_string, strlen(server_string));
1243 test_true(memc);
1244
1245 // We will just use the error strings as our keys
1246 uint32_t counter= 100;
1247 while (--counter)
1248 {
1249 for (int x= int(MEMCACHED_SUCCESS); x < int(MEMCACHED_MAXIMUM_RETURN); ++x)
1250 {
1251 const char *msg= memcached_strerror(memc, memcached_return_t(x));
1252 memcached_return_t ret= memcached_set(memc, msg, strlen(msg), NULL, 0, (time_t)0, (uint32_t)0);
1253 test_true_got((ret == MEMCACHED_CONNECTION_FAILURE or ret == MEMCACHED_SERVER_TEMPORARILY_DISABLED), memcached_last_error_message(memc));
1254
1255 const memcached_instance_st * disconnected_server= memcached_server_get_last_disconnect(memc);
1256 test_true(disconnected_server);
1257 test_strcmp("localhost", memcached_server_name(disconnected_server));
1258 test_true(memcached_server_port(disconnected_server) >= 8888 and memcached_server_port(disconnected_server) <= 8892);
1259
1260 if (random() % 2)
1261 {
1262 memcached_reset_last_disconnected_server(memc);
1263 }
1264 }
1265 }
1266
1267 memcached_free(memc);
1268
1269 return TEST_SUCCESS;
1270 }
1271
1272 test_return_t test_verbosity(memcached_st *memc)
1273 {
1274 test_compare(MEMCACHED_SUCCESS, memcached_verbosity(memc, 0));
1275
1276 return TEST_SUCCESS;
1277 }
1278
1279
1280 static memcached_return_t stat_printer(const memcached_instance_st * server,
1281 const char *key, size_t key_length,
1282 const char *value, size_t value_length,
1283 void *context)
1284 {
1285 (void)server;
1286 (void)context;
1287 (void)key;
1288 (void)key_length;
1289 (void)value;
1290 (void)value_length;
1291
1292 return MEMCACHED_SUCCESS;
1293 }
1294
1295 test_return_t memcached_stat_execute_test(memcached_st *memc)
1296 {
1297 memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL);
1298 test_compare(MEMCACHED_SUCCESS, rc);
1299
1300 test_compare(MEMCACHED_SUCCESS,
1301 memcached_stat_execute(memc, "slabs", stat_printer, NULL));
1302
1303 test_compare(MEMCACHED_SUCCESS,
1304 memcached_stat_execute(memc, "items", stat_printer, NULL));
1305
1306 test_compare(MEMCACHED_SUCCESS,
1307 memcached_stat_execute(memc, "sizes", stat_printer, NULL));
1308
1309 return TEST_SUCCESS;
1310 }
1311
1312 /*
1313 * This test ensures that the failure counter isn't incremented during
1314 * normal termination of the memcached instance.
1315 */
1316 test_return_t wrong_failure_counter_test(memcached_st *original_memc)
1317 {
1318 memcached_st* memc= create_single_instance_memcached(original_memc, NULL);
1319
1320 /* Ensure that we are connected to the server by setting a value */
1321 memcached_return_t rc= memcached_set(memc,
1322 test_literal_param(__func__), // Key
1323 test_literal_param(__func__), // Value
1324 time_t(0), uint32_t(0));
1325 test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
1326
1327
1328 const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0);
1329
1330 /* The test is to see that the memcached_quit doesn't increase the
1331 * the server failure conter, so let's ensure that it is zero
1332 * before sending quit
1333 */
1334 ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
1335
1336 memcached_quit(memc);
1337
1338 /* Verify that it memcached_quit didn't increment the failure counter
1339 * Please note that this isn't bullet proof, because an error could
1340 * occur...
1341 */
1342 test_zero(instance->server_failure_counter);
1343
1344 memcached_free(memc);
1345
1346 return TEST_SUCCESS;
1347 }
1348
1349 /*
1350 * This tests ensures expected disconnections (for some behavior changes
1351 * for instance) do not wrongly increase failure counter
1352 */
1353 test_return_t wrong_failure_counter_two_test(memcached_st *memc)
1354 {
1355 /* Set value to force connection to the server */
1356 const char *key= "marmotte";
1357 const char *value= "milka";
1358
1359 test_compare_hint(MEMCACHED_SUCCESS,
1360 memcached_set(memc, key, strlen(key),
1361 value, strlen(value),
1362 (time_t)0, (uint32_t)0),
1363 memcached_last_error_message(memc));
1364
1365
1366 /* put failure limit to 1 */
1367 test_compare(MEMCACHED_SUCCESS,
1368 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, true));
1369
1370 /* Put a retry timeout to effectively activate failure_limit effect */
1371 test_compare(MEMCACHED_SUCCESS,
1372 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1));
1373
1374 /* change behavior that triggers memcached_quit()*/
1375 test_compare(MEMCACHED_SUCCESS,
1376 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true));
1377
1378
1379 /* Check if we still are connected */
1380 uint32_t flags;
1381 size_t string_length;
1382 memcached_return rc;
1383 char *string= memcached_get(memc, key, strlen(key),
1384 &string_length, &flags, &rc);
1385
1386 test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
1387 test_true(string);
1388 free(string);
1389
1390 return TEST_SUCCESS;
1391 }
1392
1393
1394 test_return_t regression_1021819_TEST(memcached_st *original)
1395 {
1396 memcached_st *memc= memcached_clone(NULL, original);
1397 test_true(memc);
1398
1399 test_compare(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 2000000), MEMCACHED_SUCCESS);
1400 test_compare(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 3000000), MEMCACHED_SUCCESS);
1401
1402 memcached_return_t rc;
1403
1404 memcached_get(memc,
1405 test_literal_param(__func__),
1406 NULL, NULL, &rc);
1407
1408 test_compare(rc, MEMCACHED_NOTFOUND);
1409
1410 memcached_free(memc);
1411
1412 return TEST_SUCCESS;
1413 }
1414
1415 test_return_t regression_bug_583031(memcached_st *)
1416 {
1417 memcached_st *memc= memcached_create(NULL);
1418 test_true(memc);
1419 test_compare(MEMCACHED_SUCCESS, memcached_server_add(memc, "10.2.251.4", 11211));
1420
1421 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 3000);
1422 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);
1423 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
1424 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
1425 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
1426 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3);
1427
1428 memcached_return_t rc;
1429 size_t length;
1430 uint32_t flags;
1431
1432 const char *value= memcached_get(memc, "dsf", 3, &length, &flags, &rc);
1433 test_false(value);
1434 test_zero(length);
1435
1436 test_compare(MEMCACHED_TIMEOUT, memc);
1437
1438 memcached_free(memc);
1439
1440 return TEST_SUCCESS;
1441 }
1442
1443 test_return_t regression_bug_581030(memcached_st *)
1444 {
1445 #ifndef DEBUG
1446 memcached_stat_st *local_stat= memcached_stat(NULL, NULL, NULL);
1447 test_false(local_stat);
1448
1449 memcached_stat_free(NULL, NULL);
1450 #endif
1451
1452 return TEST_SUCCESS;
1453 }
1454
1455 #define regression_bug_655423_COUNT 6000
1456 test_return_t regression_bug_655423(memcached_st *memc)
1457 {
1458 memcached_st *clone= memcached_clone(NULL, memc);
1459 memc= NULL; // Just to make sure it is not used
1460 test_true(clone);
1461 char payload[100];
1462
1463 #ifdef __APPLE__
1464 return TEST_SKIPPED;
1465 #endif
1466
1467 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
1468 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1));
1469 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1));
1470 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH, 1));
1471
1472 memset(payload, int('x'), sizeof(payload));
1473
1474 keys_st keys(regression_bug_655423_COUNT);
1475
1476 for (size_t x= 0; x < keys.size(); x++)
1477 {
1478 test_compare(MEMCACHED_SUCCESS, memcached_set(clone,
1479 keys.key_at(x),
1480 keys.length_at(x),
1481 payload, sizeof(payload), 0, 0));
1482 }
1483
1484 for (size_t x= 0; x < keys.size(); x++)
1485 {
1486 size_t value_length;
1487 memcached_return_t rc;
1488 char *value= memcached_get(clone,
1489 keys.key_at(x),
1490 keys.length_at(x),
1491 &value_length, NULL, &rc);
1492
1493 if (rc == MEMCACHED_NOTFOUND)
1494 {
1495 test_false(value);
1496 test_zero(value_length);
1497 continue;
1498 }
1499
1500 test_compare(MEMCACHED_SUCCESS, rc);
1501 test_true(value);
1502 test_compare(100LLU, value_length);
1503 free(value);
1504 }
1505
1506 test_compare(MEMCACHED_SUCCESS,
1507 memcached_mget(clone,
1508 keys.keys_ptr(), keys.lengths_ptr(),
1509 keys.size()));
1510
1511 uint32_t count= 0;
1512 memcached_result_st *result= NULL;
1513 while ((result= memcached_fetch_result(clone, result, NULL)))
1514 {
1515 test_compare(size_t(100), memcached_result_length(result));
1516 count++;
1517 }
1518
1519 test_true(count > 100); // If we don't get back atleast this, something is up
1520
1521 memcached_free(clone);
1522
1523 return TEST_SUCCESS;
1524 }
1525
1526 /*
1527 * Test that ensures that buffered set to not trigger problems during io_flush
1528 */
1529 #define regression_bug_490520_COUNT 200480
1530 test_return_t regression_bug_490520(memcached_st *original_memc)
1531 {
1532 memcached_st* memc= create_single_instance_memcached(original_memc, NULL);
1533
1534 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK,1);
1535 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS,1);
1536 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
1537 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT,1);
1538 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 3600);
1539
1540 /* First add all of the items.. */
1541 char blob[3333] = {0};
1542 for (uint32_t x= 0; x < regression_bug_490520_COUNT; ++x)
1543 {
1544 char key[251];
1545 int key_length= snprintf(key, sizeof(key), "0200%u", x);
1546
1547 memcached_return rc= memcached_set(memc, key, key_length, blob, sizeof(blob), 0, 0);
1548 test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_last_error_message(memc));
1549 }
1550
1551 memcached_free(memc);
1552
1553 return TEST_SUCCESS;
1554 }
1555
1556 test_return_t regression_bug_1251482(memcached_st*)
1557 {
1558 test::Memc memc("--server=localhost:5");
1559
1560 memcached_behavior_set(&memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 0);
1561
1562 for (size_t x= 0; x < 5; ++x)
1563 {
1564 size_t value_length;
1565 memcached_return_t rc;
1566 char *value= memcached_get(&memc,
1567 test_literal_param(__func__),
1568 &value_length, NULL, &rc);
1569
1570 test_false(value);
1571 test_compare(0LLU, value_length);
1572 if (x) {
1573 test_ne_compare(MEMCACHED_SUCCESS, rc);
1574 } else {
1575 test_compare(MEMCACHED_CONNECTION_FAILURE, rc);
1576 }
1577 }
1578
1579 return TEST_SUCCESS;
1580 }
1581
1582 test_return_t regression_1009493_TEST(memcached_st*)
1583 {
1584 memcached_st* memc= memcached_create(NULL);
1585 test_true(memc);
1586 test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, true));
1587
1588 memcached_st* clone= memcached_clone(NULL, memc);
1589 test_true(clone);
1590
1591 test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED),
1592 memcached_behavior_get(clone, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED));
1593
1594 memcached_free(memc);
1595 memcached_free(clone);
1596
1597 return TEST_SUCCESS;
1598 }
1599
1600 test_return_t regression_994772_TEST(memcached_st* memc)
1601 {
1602 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
1603
1604 test_compare(MEMCACHED_SUCCESS,
1605 memcached_set(memc,
1606 test_literal_param(__func__), // Key
1607 test_literal_param(__func__), // Value
1608 time_t(0), uint32_t(0)));
1609
1610 const char *keys[] = { __func__ };
1611 size_t key_length[]= { strlen(__func__) };
1612 test_compare(MEMCACHED_SUCCESS,
1613 memcached_mget(memc, keys, key_length, 1));
1614
1615 memcached_return_t rc;
1616 memcached_result_st *results= memcached_fetch_result(memc, NULL, &rc);
1617 test_true(results);
1618 test_compare(MEMCACHED_SUCCESS, rc);
1619
1620 test_strcmp(__func__, memcached_result_value(results));
1621 uint64_t cas_value= memcached_result_cas(results);
1622 test_true(cas_value);
1623
1624 char* take_value= memcached_result_take_value(results);
1625 test_strcmp(__func__, take_value);
1626 free(take_value);
1627
1628 memcached_result_free(results);
1629
1630 // Bad cas value, sanity check
1631 test_true(cas_value != 9999);
1632 test_compare(MEMCACHED_END,
1633 memcached_cas(memc,
1634 test_literal_param(__func__), // Key
1635 test_literal_param(__FILE__), // Value
1636 time_t(0), uint32_t(0), 9999));
1637
1638 test_compare(MEMCACHED_SUCCESS, memcached_set(memc,
1639 "different", strlen("different"), // Key
1640 test_literal_param(__FILE__), // Value
1641 time_t(0), uint32_t(0)));
1642
1643 return TEST_SUCCESS;
1644 }
1645
1646 test_return_t regression_bug_854604(memcached_st *)
1647 {
1648 char buffer[1024];
1649
1650 test_compare(MEMCACHED_INVALID_ARGUMENTS, libmemcached_check_configuration(0, 0, buffer, 0));
1651
1652 test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 0));
1653
1654 test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 1));
1655 test_compare(buffer[0], 0);
1656
1657 test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 10));
1658 test_true(strlen(buffer));
1659
1660 test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, sizeof(buffer)));
1661 test_true(strlen(buffer));
1662
1663 return TEST_SUCCESS;
1664 }
1665
1666 static void die_message(memcached_st* mc, memcached_return error, const char* what, uint32_t it)
1667 {
1668 fprintf(stderr, "Iteration #%u: ", it);
1669
1670 if (error == MEMCACHED_ERRNO)
1671 {
1672 fprintf(stderr, "system error %d from %s: %s\n",
1673 errno, what, strerror(errno));
1674 }
1675 else
1676 {
1677 fprintf(stderr, "error %d from %s: %s\n", error, what,
1678 memcached_strerror(mc, error));
1679 }
1680 }
Resurrection of libmemcached https://launchpad.net/libmemcached