projects / awesomized / libmemcached / blob
? search:


ddb4c1a6e7eb44eb78830cbbe0a13a73d899696c
[awesomized/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 /* We don't test the behavior itself, we test the switches */
470 test_return_t behavior_test(memcached_st *memc)
471 {
472 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
473 test_compare(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK));
474
475 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
476 test_compare(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY));
477
478 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_MD5);
479 test_compare(uint64_t(MEMCACHED_HASH_MD5), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH));
480
481 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
482 test_zero(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK));
483
484 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
485 test_zero(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY));
486
487 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_DEFAULT);
488 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH));
489
490 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_CRC);
491 test_compare(uint64_t(MEMCACHED_HASH_CRC), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH));
492
493 test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE));
494
495 test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE));
496
497 uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
498 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value +1);
499 test_compare((value +1), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));
500
501 return TEST_SUCCESS;
502 }
503
504 test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc)
505 {
506 test_compare(MEMCACHED_DEPRECATED,
507 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, true));
508
509 // Platform dependent
510 #if 0
511 bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_CORK);
512 test_false(value);
513 #endif
514
515 return TEST_SUCCESS;
516 }
517
518
519 test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc)
520 {
521 memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, true);
522 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
523
524 bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE);
525
526 if (memcached_success(rc))
527 {
528 test_true(value);
529 }
530 else
531 {
532 test_false(value);
533 }
534
535 return TEST_SUCCESS;
536 }
537
538
539 test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc)
540 {
541 memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, true);
542 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
543
544 bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE);
545
546 if (memcached_success(rc))
547 {
548 test_true(value);
549 }
550 else
551 {
552 test_false(value);
553 }
554
555 return TEST_SUCCESS;
556 }
557
558 /* Make sure we behave properly if server list has no values */
559 test_return_t user_supplied_bug4(memcached_st *memc)
560 {
561 const char *keys[]= {"fudge", "son", "food"};
562 size_t key_length[]= {5, 3, 4};
563
564 /* Here we free everything before running a bunch of mget tests */
565 memcached_servers_reset(memc);
566
567
568 /* We need to empty the server before continueing test */
569 test_compare(MEMCACHED_NO_SERVERS,
570 memcached_flush(memc, 0));
571
572 test_compare(MEMCACHED_NO_SERVERS,
573 memcached_mget(memc, keys, key_length, 3));
574
575 {
576 unsigned int keys_returned;
577 memcached_return_t rc;
578 test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, rc));
579 test_compare(MEMCACHED_NOTFOUND, rc);
580 test_zero(keys_returned);
581 }
582
583 for (uint32_t x= 0; x < 3; x++)
584 {
585 test_compare(MEMCACHED_NO_SERVERS,
586 memcached_set(memc, keys[x], key_length[x],
587 keys[x], key_length[x],
588 (time_t)50, (uint32_t)9));
589 }
590
591 test_compare(MEMCACHED_NO_SERVERS,
592 memcached_mget(memc, keys, key_length, 3));
593
594 {
595 char *return_value;
596 char return_key[MEMCACHED_MAX_KEY];
597 memcached_return_t rc;
598 size_t return_key_length;
599 size_t return_value_length;
600 uint32_t flags;
601 uint32_t x= 0;
602 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
603 &return_value_length, &flags, &rc)))
604 {
605 test_true(return_value);
606 test_compare(MEMCACHED_SUCCESS, rc);
607 test_true(return_key_length == return_value_length);
608 test_memcmp(return_value, return_key, return_value_length);
609 free(return_value);
610 x++;
611 }
612 }
613
614 return TEST_SUCCESS;
615 }
616
617 #define VALUE_SIZE_BUG5 1048064
618 test_return_t user_supplied_bug5(memcached_st *memc)
619 {
620 const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
621 size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
622 char *value;
623 size_t value_length;
624 uint32_t flags;
625 char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
626
627 for (uint32_t x= 0; x < VALUE_SIZE_BUG5; x++)
628 {
629 insert_data[x]= (signed char)rand();
630 }
631
632 test_compare(MEMCACHED_SUCCESS,
633 memcached_flush(memc, 0));
634
635 memcached_return_t rc;
636 test_null(memcached_get(memc, keys[0], key_length[0], &value_length, &flags, &rc));
637 test_compare(MEMCACHED_SUCCESS,
638 memcached_mget(memc, keys, key_length, 4));
639
640 unsigned int count;
641 test_compare(TEST_SUCCESS, fetch_all_results(memc, count, rc));
642 test_compare(MEMCACHED_NOTFOUND, rc);
643 test_zero(count);
644
645 for (uint32_t x= 0; x < 4; x++)
646 {
647 test_compare(MEMCACHED_SUCCESS,
648 memcached_set(memc, keys[x], key_length[x],
649 insert_data, VALUE_SIZE_BUG5,
650 (time_t)0, (uint32_t)0));
651 }
652
653 for (uint32_t x= 0; x < 10; x++)
654 {
655 value= memcached_get(memc, keys[0], key_length[0],
656 &value_length, &flags, &rc);
657 test_compare(rc, MEMCACHED_SUCCESS);
658 test_true(value);
659 ::free(value);
660
661 test_compare(MEMCACHED_SUCCESS,
662 memcached_mget(memc, keys, key_length, 4));
663
664 test_compare(TEST_SUCCESS, fetch_all_results(memc, count));
665 test_compare(4U, count);
666 }
667 delete [] insert_data;
668
669 return TEST_SUCCESS;
670 }
671
672 test_return_t user_supplied_bug6(memcached_st *memc)
673 {
674 const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
675 size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
676 char return_key[MEMCACHED_MAX_KEY];
677 size_t return_key_length;
678 char *value;
679 size_t value_length;
680 uint32_t flags;
681 char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
682
683 for (uint32_t x= 0; x < VALUE_SIZE_BUG5; x++)
684 {
685 insert_data[x]= (signed char)rand();
686 }
687
688 test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));
689
690 test_compare(TEST_SUCCESS, confirm_keys_dont_exist(memc, keys, test_array_length(keys)));
691
692 // We will now confirm that memcached_mget() returns success, but we will
693 // then check to make sure that no actual keys are returned.
694 test_compare(MEMCACHED_SUCCESS,
695 memcached_mget(memc, keys, key_length, 4));
696
697 memcached_return_t rc;
698 uint32_t count= 0;
699 while ((value= memcached_fetch(memc, return_key, &return_key_length,
700 &value_length, &flags, &rc)))
701 {
702 count++;
703 }
704 test_zero(count);
705 test_compare(MEMCACHED_NOTFOUND, rc);
706
707 for (uint32_t x= 0; x < test_array_length(keys); x++)
708 {
709 test_compare(MEMCACHED_SUCCESS,
710 memcached_set(memc, keys[x], key_length[x],
711 insert_data, VALUE_SIZE_BUG5,
712 (time_t)0, (uint32_t)0));
713 }
714 test_compare(TEST_SUCCESS, confirm_keys_exist(memc, keys, test_array_length(keys)));
715
716 for (uint32_t x= 0; x < 2; x++)
717 {
718 value= memcached_get(memc, keys[0], key_length[0],
719 &value_length, &flags, &rc);
720 test_true(value);
721 free(value);
722
723 test_compare(MEMCACHED_SUCCESS,
724 memcached_mget(memc, keys, key_length, 4));
725 /* We test for purge of partial complete fetches */
726 for (count= 3; count; count--)
727 {
728 value= memcached_fetch(memc, return_key, &return_key_length,
729 &value_length, &flags, &rc);
730 test_compare(MEMCACHED_SUCCESS, rc);
731 test_memcmp(value, insert_data, value_length);
732 test_true(value_length);
733 free(value);
734 }
735 }
736 delete [] insert_data;
737
738 return TEST_SUCCESS;
739 }
740
741 test_return_t user_supplied_bug8(memcached_st *)
742 {
743 memcached_return_t rc;
744 memcached_st *mine;
745 memcached_st *memc_clone;
746
747 memcached_server_st *servers;
748 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";
749
750 servers= memcached_servers_parse(server_list);
751 test_true(servers);
752
753 mine= memcached_create(NULL);
754 rc= memcached_server_push(mine, servers);
755 test_compare(MEMCACHED_SUCCESS, rc);
756 memcached_server_list_free(servers);
757
758 test_true(mine);
759 memc_clone= memcached_clone(NULL, mine);
760
761 memcached_quit(mine);
762 memcached_quit(memc_clone);
763
764
765 memcached_free(mine);
766 memcached_free(memc_clone);
767
768 return TEST_SUCCESS;
769 }
770
771 /* Test flag store/retrieve */
772 test_return_t user_supplied_bug7(memcached_st *memc)
773 {
774 char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
775 test_true(insert_data);
776
777 for (size_t x= 0; x < VALUE_SIZE_BUG5; x++)
778 {
779 insert_data[x]= (signed char)rand();
780 }
781
782 memcached_flush(memc, 0);
783
784 const char *keys= "036790384900";
785 size_t key_length= strlen(keys);
786 test_compare(MEMCACHED_SUCCESS, memcached_set(memc, keys, key_length,
787 insert_data, VALUE_SIZE_BUG5,
788 time_t(0), 245U));
789
790 memcached_return_t rc;
791 size_t value_length;
792 uint32_t flags= 0;
793 char *value= memcached_get(memc, keys, key_length,
794 &value_length, &flags, &rc);
795 test_compare(245U, flags);
796 test_true(value);
797 free(value);
798
799 test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, &keys, &key_length, 1));
800
801 char return_key[MEMCACHED_MAX_KEY];
802 size_t return_key_length;
803 flags= 0;
804 value= memcached_fetch(memc, return_key, &return_key_length,
805 &value_length, &flags, &rc);
806 test_compare(uint32_t(245), flags);
807 test_true(value);
808 free(value);
809 delete [] insert_data;
810
811
812 return TEST_SUCCESS;
813 }
814
815 test_return_t user_supplied_bug9(memcached_st *memc)
816 {
817 const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
818 size_t key_length[3];
819 uint32_t flags;
820 unsigned count= 0;
821
822 char return_key[MEMCACHED_MAX_KEY];
823 size_t return_key_length;
824 char *return_value;
825 size_t return_value_length;
826
827
828 key_length[0]= strlen("UDATA:edevil@sapo.pt");
829 key_length[1]= strlen("fudge&*@#");
830 key_length[2]= strlen("for^#@&$not");
831
832
833 for (unsigned int x= 0; x < 3; x++)
834 {
835 memcached_return_t rc= memcached_set(memc, keys[x], key_length[x],
836 keys[x], key_length[x],
837 (time_t)50, (uint32_t)9);
838 test_compare(MEMCACHED_SUCCESS, rc);
839 }
840
841 memcached_return_t rc= memcached_mget(memc, keys, key_length, 3);
842 test_compare(MEMCACHED_SUCCESS, rc);
843
844 /* We need to empty the server before continueing test */
845 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
846 &return_value_length, &flags, &rc)) != NULL)
847 {
848 test_true(return_value);
849 free(return_value);
850 count++;
851 }
852 test_compare(3U, count);
853
854 return TEST_SUCCESS;
855 }
856
857 /* We are testing with aggressive timeout to get failures */
858 test_return_t user_supplied_bug10(memcached_st *memc)
859 {
860 test_skip(memc->servers[0].type, MEMCACHED_CONNECTION_TCP);
861
862 size_t value_length= 512;
863 unsigned int set= 1;
864 memcached_st *mclone= memcached_clone(NULL, memc);
865
866 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
867 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
868 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, uint64_t(0));
869
870 libtest::vchar_t value;
871 value.reserve(value_length);
872 for (uint32_t x= 0; x < value_length; x++)
873 {
874 value.push_back(char(x % 127));
875 }
876
877 for (unsigned int x= 1; x <= 100000; ++x)
878 {
879 memcached_return_t rc= memcached_set(mclone,
880 test_literal_param("foo"),
881 &value[0], value.size(),
882 0, 0);
883
884 test_true((rc == MEMCACHED_SUCCESS or rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_BUFFERED or rc == MEMCACHED_TIMEOUT or rc == MEMCACHED_CONNECTION_FAILURE
885 or rc == MEMCACHED_SERVER_TEMPORARILY_DISABLED));
886
887 if (rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_TIMEOUT)
888 {
889 x--;
890 }
891 }
892
893 memcached_free(mclone);
894
895 return TEST_SUCCESS;
896 }
897
898 /*
899 We are looking failures in the async protocol
900 */
901 test_return_t user_supplied_bug11(memcached_st *memc)
902 {
903 (void)memc;
904 #ifndef __APPLE__
905 test::Memc mclone(memc);
906
907 memcached_behavior_set(&mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, true);
908 memcached_behavior_set(&mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);
909 memcached_behavior_set(&mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, size_t(-1));
910
911 test_compare(-1, int32_t(memcached_behavior_get(&mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT)));
912
913 libtest::vchar_t value;
914 value.reserve(512);
915 for (unsigned int x= 0; x < 512; x++)
916 {
917 value.push_back(char(x % 127));
918 }
919
920 for (unsigned int x= 1; x <= 100000; ++x)
921 {
922 memcached_return_t rc= memcached_set(&mclone, test_literal_param("foo"), &value[0], value.size(), 0, 0);
923 (void)rc;
924 }
925
926 #endif
927
928 return TEST_SUCCESS;
929 }
930
931 /*
932 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
933 */
934 test_return_t user_supplied_bug12(memcached_st *memc)
935 {
936 memcached_return_t rc;
937 uint32_t flags;
938 size_t value_length;
939 char *value;
940 uint64_t number_value;
941
942 value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
943 &value_length, &flags, &rc);
944 test_null(value);
945 test_compare(MEMCACHED_NOTFOUND, rc);
946
947 rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
948 1, &number_value);
949 test_null(value);
950 /* The binary protocol will set the key if it doesn't exist */
951 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
952 {
953 test_compare(MEMCACHED_SUCCESS, rc);
954 }
955 else
956 {
957 test_compare(MEMCACHED_NOTFOUND, rc);
958 }
959
960 test_compare(MEMCACHED_SUCCESS,
961 memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
962
963 value= memcached_get(memc, "autoincrement", strlen("autoincrement"), &value_length, &flags, &rc);
964 test_true(value);
965 free(value);
966
967 test_compare(MEMCACHED_SUCCESS,
968 memcached_increment(memc, "autoincrement", strlen("autoincrement"), 1, &number_value));
969 test_compare(2UL, number_value);
970
971 return TEST_SUCCESS;
972 }
973
974 /*
975 Bug found where command total one more than MEMCACHED_MAX_BUFFER
976 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
977 */
978 test_return_t user_supplied_bug13(memcached_st *memc)
979 {
980 char key[] = "key34567890";
981
982 char commandFirst[]= "set key34567890 0 0 ";
983 char commandLast[] = " \r\n"; /* first line of command sent to server */
984 size_t commandLength;
985
986 commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
987
988 size_t overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
989
990 for (size_t testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
991 {
992 char *overflow= new (std::nothrow) char[testSize];
993 test_true(overflow);
994
995 memset(overflow, 'x', testSize);
996 test_compare(MEMCACHED_SUCCESS,
997 memcached_set(memc, key, strlen(key),
998 overflow, testSize, 0, 0));
999 delete [] overflow;
1000 }
1001
1002 return TEST_SUCCESS;
1003 }
1004
1005
1006 /*
1007 Test values of many different sizes
1008 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1009 set key34567890 0 0 8169 \r\n
1010 is sent followed by buffer of size 8169, followed by 8169
1011 */
1012 test_return_t user_supplied_bug14(memcached_st *memc)
1013 {
1014 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);
1015
1016 libtest::vchar_t value;
1017 value.reserve(18000);
1018 for (ptrdiff_t x= 0; x < 18000; x++)
1019 {
1020 value.push_back((char) (x % 127));
1021 }
1022
1023 for (size_t current_length= 1; current_length < value.size(); current_length++)
1024 {
1025 memcached_return_t rc= memcached_set(memc, test_literal_param("foo"),
1026 &value[0], current_length,
1027 (time_t)0, (uint32_t)0);
1028 ASSERT_TRUE_(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, "Instead got %s", memcached_strerror(NULL, rc));
1029
1030 size_t string_length;
1031 uint32_t flags;
1032 char *string= memcached_get(memc, test_literal_param("foo"),
1033 &string_length, &flags, &rc);
1034
1035 test_compare(MEMCACHED_SUCCESS, rc);
1036 test_compare(string_length, current_length);
1037 char buffer[1024];
1038 snprintf(buffer, sizeof(buffer), "%u", uint32_t(string_length));
1039 test_memcmp(string, &value[0], string_length);
1040
1041 free(string);
1042 }
1043
1044 return TEST_SUCCESS;
1045 }
1046
1047 /*
1048 Look for zero length value problems
1049 */
1050 test_return_t user_supplied_bug15(memcached_st *memc)
1051 {
1052 for (uint32_t x= 0; x < 2; x++)
1053 {
1054 memcached_return_t rc= memcached_set(memc, test_literal_param("mykey"),
1055 NULL, 0,
1056 (time_t)0, (uint32_t)0);
1057
1058 test_compare(MEMCACHED_SUCCESS, rc);
1059
1060 size_t length;
1061 uint32_t flags;
1062 char *value= memcached_get(memc, test_literal_param("mykey"),
1063 &length, &flags, &rc);
1064
1065 test_compare(MEMCACHED_SUCCESS, rc);
1066 test_false(value);
1067 test_zero(length);
1068 test_zero(flags);
1069
1070 value= memcached_get(memc, test_literal_param("mykey"),
1071 &length, &flags, &rc);
1072
1073 test_compare(MEMCACHED_SUCCESS, rc);
1074 test_null(value);
1075 test_zero(length);
1076 test_zero(flags);
1077 }
1078
1079 return TEST_SUCCESS;
1080 }
1081
1082 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
1083 test_return_t user_supplied_bug16(memcached_st *memc)
1084 {
1085 test_compare(MEMCACHED_SUCCESS, memcached_set(memc, test_literal_param("mykey"),
1086 NULL, 0,
1087 (time_t)0, UINT32_MAX));
1088
1089
1090 size_t length;
1091 uint32_t flags;
1092 memcached_return_t rc;
1093 char *value= memcached_get(memc, test_literal_param("mykey"),
1094 &length, &flags, &rc);
1095
1096 test_compare(MEMCACHED_SUCCESS, rc);
1097 test_null(value);
1098 test_zero(length);
1099 test_compare(flags, UINT32_MAX);
1100
1101 return TEST_SUCCESS;
1102 }
1103
1104 #if !defined(__sun) && !defined(__OpenBSD__)
1105 /* Check the validity of chinese key*/
1106 test_return_t user_supplied_bug17(memcached_st *memc)
1107 {
1108 const char *key= "豆瓣";
1109 const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
1110 memcached_return_t rc= memcached_set(memc, key, strlen(key),
1111 value, strlen(value),
1112 (time_t)0, 0);
1113
1114 test_compare(MEMCACHED_SUCCESS, rc);
1115
1116 size_t length;
1117 uint32_t flags;
1118 char *value2= memcached_get(memc, key, strlen(key),
1119 &length, &flags, &rc);
1120
1121 test_compare(length, strlen(value));
1122 test_compare(MEMCACHED_SUCCESS, rc);
1123 test_memcmp(value, value2, length);
1124 free(value2);
1125
1126 return TEST_SUCCESS;
1127 }
1128 #endif
1129
1130 /*
1131 From Andrei on IRC
1132 */
1133
1134 test_return_t user_supplied_bug19(memcached_st *)
1135 {
1136 memcached_return_t res;
1137
1138 memcached_st *memc= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
1139
1140 const memcached_instance_st * server= memcached_server_by_key(memc, "a", 1, &res);
1141 test_true(server);
1142
1143 memcached_free(memc);
1144
1145 return TEST_SUCCESS;
1146 }
1147
1148 /* CAS test from Andei */
1149 test_return_t user_supplied_bug20(memcached_st *memc)
1150 {
1151 const char *key= "abc";
1152 size_t key_len= strlen("abc");
1153
1154 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));
1155
1156 test_compare(MEMCACHED_SUCCESS,
1157 memcached_set(memc,
1158 test_literal_param("abc"),
1159 test_literal_param("foobar"),
1160 (time_t)0, (uint32_t)0));
1161
1162 test_compare(MEMCACHED_SUCCESS,
1163 memcached_mget(memc, &key, &key_len, 1));
1164
1165 memcached_result_st result_obj;
1166 memcached_result_st *result= memcached_result_create(memc, &result_obj);
1167 test_true(result);
1168
1169 memcached_result_create(memc, &result_obj);
1170 memcached_return_t status;
1171 result= memcached_fetch_result(memc, &result_obj, &status);
1172
1173 test_true(result);
1174 test_compare(MEMCACHED_SUCCESS, status);
1175
1176 memcached_result_free(result);
1177
1178 return TEST_SUCCESS;
1179 }
1180
1181 /* Large mget() of missing keys with binary proto
1182 *
1183 * If many binary quiet commands (such as getq's in an mget) fill the output
1184 * buffer and the server chooses not to respond, memcached_flush hangs. See
1185 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
1186 */
1187
1188 /* sighandler_t function that always asserts false */
1189 static __attribute__((noreturn)) void fail(int)
1190 {
1191 fatal_assert(0);
1192 }
1193
1194
1195 test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)
1196 {
1197 #ifdef WIN32
1198 (void)memc;
1199 (void)key_count;
1200 return TEST_SKIPPED;
1201 #else
1202 void (*oldalarm)(int);
1203
1204 memcached_st *memc_clone= memcached_clone(NULL, memc);
1205 test_true(memc_clone);
1206
1207 /* only binproto uses getq for mget */
1208 test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true));
1209
1210 /* empty the cache to ensure misses (hence non-responses) */
1211 test_compare(MEMCACHED_SUCCESS, memcached_flush(memc_clone, 0));
1212
1213 keys_st keys(key_count);
1214
1215 oldalarm= signal(SIGALRM, fail);
1216 alarm(5);
1217
1218 test_compare_got(MEMCACHED_SUCCESS,
1219 memcached_mget(memc_clone, keys.keys_ptr(), keys.lengths_ptr(), keys.size()),
1220 memcached_last_error_message(memc_clone));
1221
1222 alarm(0);
1223 signal(SIGALRM, oldalarm);
1224
1225 memcached_return_t rc;
1226 uint32_t flags;
1227 char return_key[MEMCACHED_MAX_KEY];
1228 size_t return_key_length;
1229 char *return_value;
1230 size_t return_value_length;
1231 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1232 &return_value_length, &flags, &rc)))
1233 {
1234 test_false(return_value); // There are no keys to fetch, so the value should never be returned
1235 }
1236 test_compare(MEMCACHED_NOTFOUND, rc);
1237 test_zero(return_value_length);
1238 test_zero(return_key_length);
1239 test_false(return_key[0]);
1240 test_false(return_value);
1241
1242 memcached_free(memc_clone);
1243
1244 return TEST_SUCCESS;
1245 #endif
1246 }
1247
1248 test_return_t user_supplied_bug21(memcached_st *memc)
1249 {
1250 test_skip(TEST_SUCCESS, pre_binary(memc));
1251
1252 /* should work as of r580 */
1253 test_compare(TEST_SUCCESS,
1254 _user_supplied_bug21(memc, 10));
1255
1256 /* should fail as of r580 */
1257 test_compare(TEST_SUCCESS,
1258 _user_supplied_bug21(memc, 1000));
1259
1260 return TEST_SUCCESS;
1261 }
1262
1263 test_return_t comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st *)
1264 {
1265 test::Memc memc_;
1266
1267 memcached_st *memc= &memc_;
1268
1269 ASSERT_EQ(memc, MEMCACHED_SUCCESS);
1270 test_compare(memc, MEMCACHED_SUCCESS);
1271
1272 ASSERT_NEQ(memc, MEMCACHED_FAILURE);
1273
1274 return TEST_SUCCESS;
1275 }
1276
1277 test_return_t result_static(memcached_st *memc)
1278 {
1279 memcached_result_st result;
1280 memcached_result_st *result_ptr= memcached_result_create(memc, &result);
1281 test_false(result.options.is_allocated);
1282 test_true(memcached_is_initialized(&result));
1283 test_true(result_ptr);
1284 test_true(result_ptr == &result);
1285
1286 memcached_result_free(&result);
1287
1288 test_false(result.options.is_allocated);
1289 test_false(memcached_is_initialized(&result));
1290
1291 return TEST_SUCCESS;
1292 }
1293
1294 test_return_t result_alloc(memcached_st *memc)
1295 {
1296 memcached_result_st *result_ptr= memcached_result_create(memc, NULL);
1297 test_true(result_ptr);
1298 test_true(result_ptr->options.is_allocated);
1299 test_true(memcached_is_initialized(result_ptr));
1300 memcached_result_free(result_ptr);
1301
1302 return TEST_SUCCESS;
1303 }
1304
1305
1306 static void my_free(const memcached_st *ptr, void *mem, void *context)
1307 {
1308 (void)context;
1309 (void)ptr;
1310 #ifdef HARD_MALLOC_TESTS
1311 void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8);
1312 free(real_ptr);
1313 #else
1314 free(mem);
1315 #endif
1316 }
1317
1318
1319 static void *my_malloc(const memcached_st *ptr, const size_t size, void *context)
1320 {
1321 (void)context;
1322 (void)ptr;
1323 #ifdef HARD_MALLOC_TESTS
1324 void *ret= malloc(size + 8);
1325 if (ret != NULL)
1326 {
1327 ret= (void*)((caddr_t)ret + 8);
1328 }
1329 #else
1330 void *ret= malloc(size);
1331 #endif
1332
1333 if (ret != NULL)
1334 {
1335 memset(ret, 0xff, size);
1336 }
1337
1338 return ret;
1339 }
1340
1341
1342 static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *)
1343 {
1344 #ifdef HARD_MALLOC_TESTS
1345 void *real_ptr= (mem == NULL) ? NULL : (void*)((caddr_t)mem - 8);
1346 void *nmem= realloc(real_ptr, size + 8);
1347
1348 void *ret= NULL;
1349 if (nmem != NULL)
1350 {
1351 ret= (void*)((caddr_t)nmem + 8);
1352 }
1353
1354 return ret;
1355 #else
1356 (void)ptr;
1357 return realloc(mem, size);
1358 #endif
1359 }
1360
1361
1362 static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *)
1363 {
1364 #ifdef HARD_MALLOC_TESTS
1365 void *mem= my_malloc(ptr, nelem * size);
1366 if (mem)
1367 {
1368 memset(mem, 0, nelem * size);
1369 }
1370
1371 return mem;
1372 #else
1373 (void)ptr;
1374 return calloc(nelem, size);
1375 #endif
1376 }
1377
1378 #ifdef MEMCACHED_ENABLE_DEPRECATED
1379 test_return_t deprecated_set_memory_alloc(memcached_st *memc)
1380 {
1381 void *test_ptr= NULL;
1382 void *cb_ptr= NULL;
1383 {
1384 memcached_malloc_fn malloc_cb= (memcached_malloc_fn)my_malloc;
1385 cb_ptr= *(void **)&malloc_cb;
1386 memcached_return_t rc;
1387
1388 test_compare(MEMCACHED_SUCCESS,
1389 memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, cb_ptr));
1390 test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
1391 test_compare(MEMCACHED_SUCCESS, rc);
1392 test_true(test_ptr == cb_ptr);
1393 }
1394
1395 {
1396 memcached_realloc_fn realloc_cb=
1397 (memcached_realloc_fn)my_realloc;
1398 cb_ptr= *(void **)&realloc_cb;
1399 memcached_return_t rc;
1400
1401 test_compare(MEMCACHED_SUCCESS,
1402 memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, cb_ptr));
1403 test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
1404 test_compare(MEMCACHED_SUCCESS, rc);
1405 test_true(test_ptr == cb_ptr);
1406 }
1407
1408 {
1409 memcached_free_fn free_cb=
1410 (memcached_free_fn)my_free;
1411 cb_ptr= *(void **)&free_cb;
1412 memcached_return_t rc;
1413
1414 test_compare(MEMCACHED_SUCCESS,
1415 memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, cb_ptr));
1416 test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
1417 test_compare(MEMCACHED_SUCCESS, rc);
1418 test_true(test_ptr == cb_ptr);
1419 }
1420
1421 return TEST_SUCCESS;
1422 }
1423 #endif
1424
1425
1426 test_return_t set_memory_alloc(memcached_st *memc)
1427 {
1428 test_compare(MEMCACHED_INVALID_ARGUMENTS,
1429 memcached_set_memory_allocators(memc, NULL, my_free,
1430 my_realloc, my_calloc, NULL));
1431
1432 test_compare(MEMCACHED_SUCCESS,
1433 memcached_set_memory_allocators(memc, my_malloc, my_free,
1434 my_realloc, my_calloc, NULL));
1435
1436 memcached_malloc_fn mem_malloc;
1437 memcached_free_fn mem_free;
1438 memcached_realloc_fn mem_realloc;
1439 memcached_calloc_fn mem_calloc;
1440 memcached_get_memory_allocators(memc, &mem_malloc, &mem_free,
1441 &mem_realloc, &mem_calloc);
1442
1443 test_true(mem_malloc == my_malloc);
1444 test_true(mem_realloc == my_realloc);
1445 test_true(mem_calloc == my_calloc);
1446 test_true(mem_free == my_free);
1447
1448 return TEST_SUCCESS;
1449 }
1450
1451 test_return_t MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st *memc)
1452 {
1453 const uint64_t timeout= 100; // Not using, just checking that it sets
1454
1455 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
1456
1457 test_compare(timeout, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT));
1458
1459 return TEST_SUCCESS;
1460 }
1461
1462 test_return_t analyzer_test(memcached_st *memc)
1463 {
1464 memcached_analysis_st *report;
1465 memcached_return_t rc;
1466
1467 memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
1468 test_compare(MEMCACHED_SUCCESS, rc);
1469 test_true(memc_stat);
1470
1471 report= memcached_analyze(memc, memc_stat, &rc);
1472 test_compare(MEMCACHED_SUCCESS, rc);
1473 test_true(report);
1474
1475 free(report);
1476 memcached_stat_free(NULL, memc_stat);
1477
1478 return TEST_SUCCESS;
1479 }
1480
1481 test_return_t hsieh_avaibility_test (memcached_st *memc)
1482 {
1483 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH));
1484
1485 test_compare(MEMCACHED_SUCCESS,
1486 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
1487 (uint64_t)MEMCACHED_HASH_HSIEH));
1488
1489 return TEST_SUCCESS;
1490 }
1491
1492 test_return_t murmur_avaibility_test (memcached_st *memc)
1493 {
1494 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR));
1495
1496 test_compare(MEMCACHED_SUCCESS,
1497 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR));
1498
1499 return TEST_SUCCESS;
1500 }
1501
1502 /*
1503 Test case adapted from John Gorman <johngorman2@gmail.com>
1504
1505 We are testing the error condition when we connect to a server via memcached_get()
1506 but find that the server is not available.
1507 */
1508 test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *)
1509 {
1510 size_t len;
1511 uint32_t flags;
1512 memcached_return rc;
1513
1514 // Create a handle.
1515 memcached_st *tl_memc_h= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
1516
1517 // See if memcached is reachable.
1518 char *value= memcached_get(tl_memc_h,
1519 test_literal_param(__func__),
1520 &len, &flags, &rc);
1521
1522 test_false(value);
1523 test_zero(len);
1524 test_true(memcached_failed(rc));
1525
1526 memcached_free(tl_memc_h);
1527
1528 return TEST_SUCCESS;
1529 }
1530
1531 /*
1532 We connect to a server which exists, but search for a key that does not exist.
1533 */
1534 test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc)
1535 {
1536 size_t len;
1537 uint32_t flags;
1538 memcached_return rc;
1539
1540 // See if memcached is reachable.
1541 char *value= memcached_get(memc,
1542 test_literal_param(__func__),
1543 &len, &flags, &rc);
1544
1545 test_false(value);
1546 test_zero(len);
1547 test_compare(MEMCACHED_NOTFOUND, rc);
1548
1549 return TEST_SUCCESS;
1550 }
1551
1552 /*
1553 Test case adapted from John Gorman <johngorman2@gmail.com>
1554
1555 We are testing the error condition when we connect to a server via memcached_get_by_key()
1556 but find that the server is not available.
1557 */
1558 test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *)
1559 {
1560 size_t len;
1561 uint32_t flags;
1562 memcached_return rc;
1563
1564 // Create a handle.
1565 memcached_st *tl_memc_h= memcached_create(NULL);
1566 memcached_server_st *servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
1567 memcached_server_push(tl_memc_h, servers);
1568 memcached_server_list_free(servers);
1569
1570 // See if memcached is reachable.
1571 char *value= memcached_get_by_key(tl_memc_h,
1572 test_literal_param(__func__), // Key
1573 test_literal_param(__func__), // Value
1574 &len, &flags, &rc);
1575
1576 test_false(value);
1577 test_zero(len);
1578 test_true(memcached_failed(rc));
1579
1580 memcached_free(tl_memc_h);
1581
1582 return TEST_SUCCESS;
1583 }
1584
1585 /*
1586 We connect to a server which exists, but search for a key that does not exist.
1587 */
1588 test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc)
1589 {
1590 size_t len;
1591 uint32_t flags;
1592 memcached_return rc;
1593
1594 // See if memcached is reachable.
1595 char *value= memcached_get_by_key(memc,
1596 test_literal_param(__func__), // Key
1597 test_literal_param(__func__), // Value
1598 &len, &flags, &rc);
1599
1600 test_false(value);
1601 test_zero(len);
1602 test_compare(MEMCACHED_NOTFOUND, rc);
1603
1604 return TEST_SUCCESS;
1605 }
1606
1607 test_return_t regression_bug_421108(memcached_st *memc)
1608 {
1609 memcached_return_t rc;
1610 memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
1611 test_compare(MEMCACHED_SUCCESS, rc);
1612
1613 char *bytes_str= memcached_stat_get_value(memc, memc_stat, "bytes", &rc);
1614 test_compare(MEMCACHED_SUCCESS, rc);
1615 test_true(bytes_str);
1616 char *bytes_read_str= memcached_stat_get_value(memc, memc_stat,
1617 "bytes_read", &rc);
1618 test_compare(MEMCACHED_SUCCESS, rc);
1619 test_true(bytes_read_str);
1620
1621 char *bytes_written_str= memcached_stat_get_value(memc, memc_stat,
1622 "bytes_written", &rc);
1623 test_compare(MEMCACHED_SUCCESS, rc);
1624 test_true(bytes_written_str);
1625
1626 unsigned long long bytes= strtoull(bytes_str, 0, 10);
1627 unsigned long long bytes_read= strtoull(bytes_read_str, 0, 10);
1628 unsigned long long bytes_written= strtoull(bytes_written_str, 0, 10);
1629
1630 test_true(bytes != bytes_read);
1631 test_true(bytes != bytes_written);
1632
1633 /* Release allocated resources */
1634 free(bytes_str);
1635 free(bytes_read_str);
1636 free(bytes_written_str);
1637 memcached_stat_free(NULL, memc_stat);
1638
1639 return TEST_SUCCESS;
1640 }
1641
1642
1643 /* Test memcached_server_get_last_disconnect
1644 * For a working server set, shall be NULL
1645 * For a set of non existing server, shall not be NULL
1646 */
1647 test_return_t test_get_last_disconnect(memcached_st *memc)
1648 {
1649 memcached_return_t rc;
1650 const memcached_instance_st * disconnected_server;
1651
1652 /* With the working set of server */
1653 const char *key= "marmotte";
1654 const char *value= "milka";
1655
1656 memcached_reset_last_disconnected_server(memc);
1657 test_false(memc->last_disconnected_server);
1658 rc= memcached_set(memc, key, strlen(key),
1659 value, strlen(value),
1660 (time_t)0, (uint32_t)0);
1661 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1662
1663 disconnected_server = memcached_server_get_last_disconnect(memc);
1664 test_false(disconnected_server);
1665
1666 /* With a non existing server */
1667 memcached_st *mine;
1668 memcached_server_st *servers;
1669
1670 const char *server_list= "localhost:9";
1671
1672 servers= memcached_servers_parse(server_list);
1673 test_true(servers);
1674 mine= memcached_create(NULL);
1675 rc= memcached_server_push(mine, servers);
1676 test_compare(MEMCACHED_SUCCESS, rc);
1677 memcached_server_list_free(servers);
1678 test_true(mine);
1679
1680 rc= memcached_set(mine, key, strlen(key),
1681 value, strlen(value),
1682 (time_t)0, (uint32_t)0);
1683 test_true(memcached_failed(rc));
1684
1685 disconnected_server= memcached_server_get_last_disconnect(mine);
1686 test_true_got(disconnected_server, memcached_strerror(mine, rc));
1687 test_compare(in_port_t(9), memcached_server_port(disconnected_server));
1688 test_false(strncmp(memcached_server_name(disconnected_server),"localhost",9));
1689
1690 memcached_quit(mine);
1691 memcached_free(mine);
1692
1693 return TEST_SUCCESS;
1694 }
1695
1696 test_return_t test_multiple_get_last_disconnect(memcached_st *)
1697 {
1698 const char *server_string= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
1699 char buffer[BUFSIZ];
1700
1701 test_compare(MEMCACHED_SUCCESS,
1702 libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)));
1703
1704 memcached_st *memc= memcached(server_string, strlen(server_string));
1705 test_true(memc);
1706
1707 // We will just use the error strings as our keys
1708 uint32_t counter= 100;
1709 while (--counter)
1710 {
1711 for (int x= int(MEMCACHED_SUCCESS); x < int(MEMCACHED_MAXIMUM_RETURN); ++x)
1712 {
1713 const char *msg= memcached_strerror(memc, memcached_return_t(x));
1714 memcached_return_t ret= memcached_set(memc, msg, strlen(msg), NULL, 0, (time_t)0, (uint32_t)0);
1715 test_true_got((ret == MEMCACHED_CONNECTION_FAILURE or ret == MEMCACHED_SERVER_TEMPORARILY_DISABLED), memcached_last_error_message(memc));
1716
1717 const memcached_instance_st * disconnected_server= memcached_server_get_last_disconnect(memc);
1718 test_true(disconnected_server);
1719 test_strcmp("localhost", memcached_server_name(disconnected_server));
1720 test_true(memcached_server_port(disconnected_server) >= 8888 and memcached_server_port(disconnected_server) <= 8892);
1721
1722 if (random() % 2)
1723 {
1724 memcached_reset_last_disconnected_server(memc);
1725 }
1726 }
1727 }
1728
1729 memcached_free(memc);
1730
1731 return TEST_SUCCESS;
1732 }
1733
1734 test_return_t test_verbosity(memcached_st *memc)
1735 {
1736 test_compare(MEMCACHED_SUCCESS, memcached_verbosity(memc, 0));
1737
1738 return TEST_SUCCESS;
1739 }
1740
1741
1742 static memcached_return_t stat_printer(const memcached_instance_st * server,
1743 const char *key, size_t key_length,
1744 const char *value, size_t value_length,
1745 void *context)
1746 {
1747 (void)server;
1748 (void)context;
1749 (void)key;
1750 (void)key_length;
1751 (void)value;
1752 (void)value_length;
1753
1754 return MEMCACHED_SUCCESS;
1755 }
1756
1757 test_return_t memcached_stat_execute_test(memcached_st *memc)
1758 {
1759 memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL);
1760 test_compare(MEMCACHED_SUCCESS, rc);
1761
1762 test_compare(MEMCACHED_SUCCESS,
1763 memcached_stat_execute(memc, "slabs", stat_printer, NULL));
1764
1765 test_compare(MEMCACHED_SUCCESS,
1766 memcached_stat_execute(memc, "items", stat_printer, NULL));
1767
1768 test_compare(MEMCACHED_SUCCESS,
1769 memcached_stat_execute(memc, "sizes", stat_printer, NULL));
1770
1771 return TEST_SUCCESS;
1772 }
1773
1774 /*
1775 * This test ensures that the failure counter isn't incremented during
1776 * normal termination of the memcached instance.
1777 */
1778 test_return_t wrong_failure_counter_test(memcached_st *original_memc)
1779 {
1780 memcached_st* memc= create_single_instance_memcached(original_memc, NULL);
1781
1782 /* Ensure that we are connected to the server by setting a value */
1783 memcached_return_t rc= memcached_set(memc,
1784 test_literal_param(__func__), // Key
1785 test_literal_param(__func__), // Value
1786 time_t(0), uint32_t(0));
1787 test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
1788
1789
1790 const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0);
1791
1792 /* The test is to see that the memcached_quit doesn't increase the
1793 * the server failure conter, so let's ensure that it is zero
1794 * before sending quit
1795 */
1796 ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
1797
1798 memcached_quit(memc);
1799
1800 /* Verify that it memcached_quit didn't increment the failure counter
1801 * Please note that this isn't bullet proof, because an error could
1802 * occur...
1803 */
1804 test_zero(instance->server_failure_counter);
1805
1806 memcached_free(memc);
1807
1808 return TEST_SUCCESS;
1809 }
1810
1811 /*
1812 * This tests ensures expected disconnections (for some behavior changes
1813 * for instance) do not wrongly increase failure counter
1814 */
1815 test_return_t wrong_failure_counter_two_test(memcached_st *memc)
1816 {
1817 /* Set value to force connection to the server */
1818 const char *key= "marmotte";
1819 const char *value= "milka";
1820
1821 test_compare_hint(MEMCACHED_SUCCESS,
1822 memcached_set(memc, key, strlen(key),
1823 value, strlen(value),
1824 (time_t)0, (uint32_t)0),
1825 memcached_last_error_message(memc));
1826
1827
1828 /* put failure limit to 1 */
1829 test_compare(MEMCACHED_SUCCESS,
1830 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, true));
1831
1832 /* Put a retry timeout to effectively activate failure_limit effect */
1833 test_compare(MEMCACHED_SUCCESS,
1834 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1));
1835
1836 /* change behavior that triggers memcached_quit()*/
1837 test_compare(MEMCACHED_SUCCESS,
1838 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true));
1839
1840
1841 /* Check if we still are connected */
1842 uint32_t flags;
1843 size_t string_length;
1844 memcached_return rc;
1845 char *string= memcached_get(memc, key, strlen(key),
1846 &string_length, &flags, &rc);
1847
1848 test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
1849 test_true(string);
1850 free(string);
1851
1852 return TEST_SUCCESS;
1853 }
1854
1855
1856 test_return_t regression_1021819_TEST(memcached_st *original)
1857 {
1858 memcached_st *memc= memcached_clone(NULL, original);
1859 test_true(memc);
1860
1861 test_compare(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 2000000), MEMCACHED_SUCCESS);
1862 test_compare(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 3000000), MEMCACHED_SUCCESS);
1863
1864 memcached_return_t rc;
1865
1866 memcached_get(memc,
1867 test_literal_param(__func__),
1868 NULL, NULL, &rc);
1869
1870 test_compare(rc, MEMCACHED_NOTFOUND);
1871
1872 memcached_free(memc);
1873
1874 return TEST_SUCCESS;
1875 }
1876
1877 test_return_t regression_bug_583031(memcached_st *)
1878 {
1879 memcached_st *memc= memcached_create(NULL);
1880 test_true(memc);
1881 test_compare(MEMCACHED_SUCCESS, memcached_server_add(memc, "10.2.251.4", 11211));
1882
1883 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 3000);
1884 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);
1885 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
1886 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
1887 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
1888 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3);
1889
1890 memcached_return_t rc;
1891 size_t length;
1892 uint32_t flags;
1893
1894 const char *value= memcached_get(memc, "dsf", 3, &length, &flags, &rc);
1895 test_false(value);
1896 test_zero(length);
1897
1898 test_compare(MEMCACHED_TIMEOUT, memc);
1899
1900 memcached_free(memc);
1901
1902 return TEST_SUCCESS;
1903 }
1904
1905 test_return_t regression_bug_581030(memcached_st *)
1906 {
1907 #ifndef DEBUG
1908 memcached_stat_st *local_stat= memcached_stat(NULL, NULL, NULL);
1909 test_false(local_stat);
1910
1911 memcached_stat_free(NULL, NULL);
1912 #endif
1913
1914 return TEST_SUCCESS;
1915 }
1916
1917 #define regression_bug_655423_COUNT 6000
1918 test_return_t regression_bug_655423(memcached_st *memc)
1919 {
1920 memcached_st *clone= memcached_clone(NULL, memc);
1921 memc= NULL; // Just to make sure it is not used
1922 test_true(clone);
1923 char payload[100];
1924
1925 #ifdef __APPLE__
1926 return TEST_SKIPPED;
1927 #endif
1928
1929 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
1930 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1));
1931 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1));
1932 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH, 1));
1933
1934 memset(payload, int('x'), sizeof(payload));
1935
1936 keys_st keys(regression_bug_655423_COUNT);
1937
1938 for (size_t x= 0; x < keys.size(); x++)
1939 {
1940 test_compare(MEMCACHED_SUCCESS, memcached_set(clone,
1941 keys.key_at(x),
1942 keys.length_at(x),
1943 payload, sizeof(payload), 0, 0));
1944 }
1945
1946 for (size_t x= 0; x < keys.size(); x++)
1947 {
1948 size_t value_length;
1949 memcached_return_t rc;
1950 char *value= memcached_get(clone,
1951 keys.key_at(x),
1952 keys.length_at(x),
1953 &value_length, NULL, &rc);
1954
1955 if (rc == MEMCACHED_NOTFOUND)
1956 {
1957 test_false(value);
1958 test_zero(value_length);
1959 continue;
1960 }
1961
1962 test_compare(MEMCACHED_SUCCESS, rc);
1963 test_true(value);
1964 test_compare(100LLU, value_length);
1965 free(value);
1966 }
1967
1968 test_compare(MEMCACHED_SUCCESS,
1969 memcached_mget(clone,
1970 keys.keys_ptr(), keys.lengths_ptr(),
1971 keys.size()));
1972
1973 uint32_t count= 0;
1974 memcached_result_st *result= NULL;
1975 while ((result= memcached_fetch_result(clone, result, NULL)))
1976 {
1977 test_compare(size_t(100), memcached_result_length(result));
1978 count++;
1979 }
1980
1981 test_true(count > 100); // If we don't get back atleast this, something is up
1982
1983 memcached_free(clone);
1984
1985 return TEST_SUCCESS;
1986 }
1987
1988 /*
1989 * Test that ensures that buffered set to not trigger problems during io_flush
1990 */
1991 #define regression_bug_490520_COUNT 200480
1992 test_return_t regression_bug_490520(memcached_st *original_memc)
1993 {
1994 memcached_st* memc= create_single_instance_memcached(original_memc, NULL);
1995
1996 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK,1);
1997 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS,1);
1998 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
1999 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT,1);
2000 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 3600);
2001
2002 /* First add all of the items.. */
2003 char blob[3333] = {0};
2004 for (uint32_t x= 0; x < regression_bug_490520_COUNT; ++x)
2005 {
2006 char key[251];
2007 int key_length= snprintf(key, sizeof(key), "0200%u", x);
2008
2009 memcached_return rc= memcached_set(memc, key, key_length, blob, sizeof(blob), 0, 0);
2010 test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_last_error_message(memc));
2011 }
2012
2013 memcached_free(memc);
2014
2015 return TEST_SUCCESS;
2016 }
2017
2018 test_return_t regression_bug_1251482(memcached_st*)
2019 {
2020 test::Memc memc("--server=localhost:5");
2021
2022 memcached_behavior_set(&memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 0);
2023
2024 for (size_t x= 0; x < 5; ++x)
2025 {
2026 size_t value_length;
2027 memcached_return_t rc;
2028 char *value= memcached_get(&memc,
2029 test_literal_param(__func__),
2030 &value_length, NULL, &rc);
2031
2032 test_false(value);
2033 test_compare(0LLU, value_length);
2034 if (x) {
2035 test_ne_compare(MEMCACHED_SUCCESS, rc);
2036 } else {
2037 test_compare(MEMCACHED_CONNECTION_FAILURE, rc);
2038 }
2039 }
2040
2041 return TEST_SUCCESS;
2042 }
2043
2044 test_return_t regression_1009493_TEST(memcached_st*)
2045 {
2046 memcached_st* memc= memcached_create(NULL);
2047 test_true(memc);
2048 test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, true));
2049
2050 memcached_st* clone= memcached_clone(NULL, memc);
2051 test_true(clone);
2052
2053 test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED),
2054 memcached_behavior_get(clone, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED));
2055
2056 memcached_free(memc);
2057 memcached_free(clone);
2058
2059 return TEST_SUCCESS;
2060 }
2061
2062 test_return_t regression_994772_TEST(memcached_st* memc)
2063 {
2064 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
2065
2066 test_compare(MEMCACHED_SUCCESS,
2067 memcached_set(memc,
2068 test_literal_param(__func__), // Key
2069 test_literal_param(__func__), // Value
2070 time_t(0), uint32_t(0)));
2071
2072 const char *keys[] = { __func__ };
2073 size_t key_length[]= { strlen(__func__) };
2074 test_compare(MEMCACHED_SUCCESS,
2075 memcached_mget(memc, keys, key_length, 1));
2076
2077 memcached_return_t rc;
2078 memcached_result_st *results= memcached_fetch_result(memc, NULL, &rc);
2079 test_true(results);
2080 test_compare(MEMCACHED_SUCCESS, rc);
2081
2082 test_strcmp(__func__, memcached_result_value(results));
2083 uint64_t cas_value= memcached_result_cas(results);
2084 test_true(cas_value);
2085
2086 char* take_value= memcached_result_take_value(results);
2087 test_strcmp(__func__, take_value);
2088 free(take_value);
2089
2090 memcached_result_free(results);
2091
2092 // Bad cas value, sanity check
2093 test_true(cas_value != 9999);
2094 test_compare(MEMCACHED_END,
2095 memcached_cas(memc,
2096 test_literal_param(__func__), // Key
2097 test_literal_param(__FILE__), // Value
2098 time_t(0), uint32_t(0), 9999));
2099
2100 test_compare(MEMCACHED_SUCCESS, memcached_set(memc,
2101 "different", strlen("different"), // Key
2102 test_literal_param(__FILE__), // Value
2103 time_t(0), uint32_t(0)));
2104
2105 return TEST_SUCCESS;
2106 }
2107
2108 test_return_t regression_bug_854604(memcached_st *)
2109 {
2110 char buffer[1024];
2111
2112 test_compare(MEMCACHED_INVALID_ARGUMENTS, libmemcached_check_configuration(0, 0, buffer, 0));
2113
2114 test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 0));
2115
2116 test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 1));
2117 test_compare(buffer[0], 0);
2118
2119 test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 10));
2120 test_true(strlen(buffer));
2121
2122 test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, sizeof(buffer)));
2123 test_true(strlen(buffer));
2124
2125 return TEST_SUCCESS;
2126 }
2127
2128 static void die_message(memcached_st* mc, memcached_return error, const char* what, uint32_t it)
2129 {
2130 fprintf(stderr, "Iteration #%u: ", it);
2131
2132 if (error == MEMCACHED_ERRNO)
2133 {
2134 fprintf(stderr, "system error %d from %s: %s\n",
2135 errno, what, strerror(errno));
2136 }
2137 else
2138 {
2139 fprintf(stderr, "error %d from %s: %s\n", error, what,
2140 memcached_strerror(mc, error));
2141 }
2142 }
Resurrection of libmemcached