661c324ee5ba99e490703a2a1f4038724ccea37b
[awesomized/libmemcached] / tests / function.c
1 /*
2 Sample test application.
3 */
4
5 #include "libmemcached/common.h"
6
7 #include <assert.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include <sys/time.h>
12 #include <sys/types.h>
13 #include <sys/stat.h>
14 #include <unistd.h>
15 #include <time.h>
16 #include "server.h"
17 #include "clients/generator.h"
18 #include "clients/execute.h"
19
20 #ifndef INT64_MAX
21 #define INT64_MAX LONG_MAX
22 #endif
23 #ifndef INT32_MAX
24 #define INT32_MAX INT_MAX
25 #endif
26
27
28 #include "test.h"
29
30 #ifdef HAVE_LIBMEMCACHEDUTIL
31 #include <pthread.h>
32 #include "libmemcached/memcached_util.h"
33 #endif
34
35 #define GLOBAL_COUNT 10000
36 #define GLOBAL2_COUNT 100
37 #define SERVERS_TO_CREATE 5
38 static uint32_t global_count;
39
40 static pairs_st *global_pairs;
41 static const char *global_keys[GLOBAL_COUNT];
42 static size_t global_keys_length[GLOBAL_COUNT];
43
44 static test_return init_test(memcached_st *not_used __attribute__((unused)))
45 {
46 memcached_st memc;
47
48 (void)memcached_create(&memc);
49 memcached_free(&memc);
50
51 return 0;
52 }
53
54 static test_return server_list_null_test(memcached_st *ptr __attribute__((unused)))
55 {
56 memcached_server_st *server_list;
57 memcached_return rc;
58
59 server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, NULL);
60 assert(server_list == NULL);
61
62 server_list= memcached_server_list_append_with_weight(NULL, "localhost", 0, 0, NULL);
63 assert(server_list == NULL);
64
65 server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, &rc);
66 assert(server_list == NULL);
67
68 return 0;
69 }
70
71 #define TEST_PORT_COUNT 7
72 uint32_t test_ports[TEST_PORT_COUNT];
73
74 static memcached_return server_display_function(memcached_st *ptr __attribute__((unused)), memcached_server_st *server, void *context)
75 {
76 /* Do Nothing */
77 uint32_t bigger= *((uint32_t *)(context));
78 assert(bigger <= server->port);
79 *((uint32_t *)(context))= server->port;
80
81 return MEMCACHED_SUCCESS;
82 }
83
84 static test_return server_sort_test(memcached_st *ptr __attribute__((unused)))
85 {
86 uint32_t x;
87 uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */
88 memcached_return rc;
89 memcached_server_function callbacks[1];
90 memcached_st *local_memc;
91
92 local_memc= memcached_create(NULL);
93 assert(local_memc);
94 memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
95
96 for (x= 0; x < TEST_PORT_COUNT; x++)
97 {
98 test_ports[x]= (uint32_t)random() % 64000;
99 rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
100 assert(local_memc->number_of_hosts == x + 1);
101 assert(local_memc->hosts[0].count == x+1);
102 assert(rc == MEMCACHED_SUCCESS);
103 }
104
105 callbacks[0]= server_display_function;
106 memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
107
108
109 memcached_free(local_memc);
110
111 return 0;
112 }
113
114 static test_return server_sort2_test(memcached_st *ptr __attribute__((unused)))
115 {
116 uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */
117 memcached_return rc;
118 memcached_server_function callbacks[1];
119 memcached_st *local_memc;
120
121 local_memc= memcached_create(NULL);
122 assert(local_memc);
123 rc= memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
124 assert(rc == MEMCACHED_SUCCESS);
125
126 rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
127 assert(rc == MEMCACHED_SUCCESS);
128 assert(local_memc->hosts[0].port == 43043);
129
130 rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
131 assert(rc == MEMCACHED_SUCCESS);
132 assert(local_memc->hosts[0].port == 43042);
133 assert(local_memc->hosts[1].port == 43043);
134
135 callbacks[0]= server_display_function;
136 memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
137
138
139 memcached_free(local_memc);
140
141 return 0;
142 }
143
144 static memcached_return server_display_unsort_function(memcached_st *ptr __attribute__((unused)), memcached_server_st *server, void *context)
145 {
146 /* Do Nothing */
147 uint32_t x= *((uint32_t *)(context));
148
149 assert(test_ports[x] == server->port);
150 *((uint32_t *)(context))= ++x;
151
152 return MEMCACHED_SUCCESS;
153 }
154
155 static test_return server_unsort_test(memcached_st *ptr __attribute__((unused)))
156 {
157 uint32_t x;
158 uint32_t counter= 0; /* Prime the value for the assert in server_display_function */
159 uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */
160 memcached_return rc;
161 memcached_server_function callbacks[1];
162 memcached_st *local_memc;
163
164 local_memc= memcached_create(NULL);
165 assert(local_memc);
166
167 for (x= 0; x < TEST_PORT_COUNT; x++)
168 {
169 test_ports[x]= (uint32_t)(random() % 64000);
170 rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
171 assert(local_memc->number_of_hosts == x+1);
172 assert(local_memc->hosts[0].count == x+1);
173 assert(rc == MEMCACHED_SUCCESS);
174 }
175
176 callbacks[0]= server_display_unsort_function;
177 memcached_server_cursor(local_memc, callbacks, (void *)&counter, 1);
178
179 /* Now we sort old data! */
180 memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
181 callbacks[0]= server_display_function;
182 memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
183
184
185 memcached_free(local_memc);
186
187 return 0;
188 }
189
190 static test_return allocation_test(memcached_st *not_used __attribute__((unused)))
191 {
192 memcached_st *memc;
193 memc= memcached_create(NULL);
194 assert(memc);
195 memcached_free(memc);
196
197 return 0;
198 }
199
200 static test_return clone_test(memcached_st *memc)
201 {
202 /* All null? */
203 {
204 memcached_st *memc_clone;
205 memc_clone= memcached_clone(NULL, NULL);
206 assert(memc_clone);
207 memcached_free(memc_clone);
208 }
209
210 /* Can we init from null? */
211 {
212 memcached_st *memc_clone;
213 memc_clone= memcached_clone(NULL, memc);
214 assert(memc_clone);
215
216 assert(memc_clone->call_free == memc->call_free);
217 assert(memc_clone->call_malloc == memc->call_malloc);
218 assert(memc_clone->call_realloc == memc->call_realloc);
219 assert(memc_clone->call_calloc == memc->call_calloc);
220 assert(memc_clone->connect_timeout == memc->connect_timeout);
221 assert(memc_clone->delete_trigger == memc->delete_trigger);
222 assert(memc_clone->distribution == memc->distribution);
223 assert(memc_clone->flags == memc->flags);
224 assert(memc_clone->get_key_failure == memc->get_key_failure);
225 assert(memc_clone->hash == memc->hash);
226 assert(memc_clone->hash_continuum == memc->hash_continuum);
227 assert(memc_clone->io_bytes_watermark == memc->io_bytes_watermark);
228 assert(memc_clone->io_msg_watermark == memc->io_msg_watermark);
229 assert(memc_clone->io_key_prefetch == memc->io_key_prefetch);
230 assert(memc_clone->on_cleanup == memc->on_cleanup);
231 assert(memc_clone->on_clone == memc->on_clone);
232 assert(memc_clone->poll_timeout == memc->poll_timeout);
233 assert(memc_clone->rcv_timeout == memc->rcv_timeout);
234 assert(memc_clone->recv_size == memc->recv_size);
235 assert(memc_clone->retry_timeout == memc->retry_timeout);
236 assert(memc_clone->send_size == memc->send_size);
237 assert(memc_clone->server_failure_limit == memc->server_failure_limit);
238 assert(memc_clone->snd_timeout == memc->snd_timeout);
239 assert(memc_clone->user_data == memc->user_data);
240
241 memcached_free(memc_clone);
242 }
243
244 /* Can we init from struct? */
245 {
246 memcached_st declared_clone;
247 memcached_st *memc_clone;
248 memset(&declared_clone, 0 , sizeof(memcached_st));
249 memc_clone= memcached_clone(&declared_clone, NULL);
250 assert(memc_clone);
251 memcached_free(memc_clone);
252 }
253
254 /* Can we init from struct? */
255 {
256 memcached_st declared_clone;
257 memcached_st *memc_clone;
258 memset(&declared_clone, 0 , sizeof(memcached_st));
259 memc_clone= memcached_clone(&declared_clone, memc);
260 assert(memc_clone);
261 memcached_free(memc_clone);
262 }
263
264 return 0;
265 }
266
267 static test_return userdata_test(memcached_st *memc)
268 {
269 void* foo= NULL;
270 assert(memcached_set_user_data(memc, foo) == NULL);
271 assert(memcached_get_user_data(memc) == foo);
272 assert(memcached_set_user_data(memc, NULL) == foo);
273
274 return TEST_SUCCESS;
275 }
276
277 static test_return connection_test(memcached_st *memc)
278 {
279 memcached_return rc;
280
281 rc= memcached_server_add_with_weight(memc, "localhost", 0, 0);
282 assert(rc == MEMCACHED_SUCCESS);
283
284 return 0;
285 }
286
287 static test_return error_test(memcached_st *memc)
288 {
289 memcached_return rc;
290 uint32_t values[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U,
291 982370485U, 1263635348U, 4242906218U, 3829656100U,
292 1891735253U, 334139633U, 2257084983U, 3088286104U,
293 13199785U, 2542027183U, 1097051614U, 199566778U,
294 2748246961U, 2465192557U, 1664094137U, 2405439045U,
295 1842224848U, 692413798U, 3479807801U, 919913813U,
296 4269430871U, 610793021U, 527273862U, 1437122909U,
297 2300930706U, 2943759320U, 674306647U, 2400528935U,
298 54481931U, 4186304426U, 1741088401U, 2979625118U,
299 4159057246U, 3425930182U};
300
301 // You have updated the memcache_error messages but not updated docs/tests.
302 assert(MEMCACHED_MAXIMUM_RETURN == 38);
303 for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
304 {
305 uint32_t hash_val;
306 const char *msg= memcached_strerror(memc, rc);
307 hash_val= memcached_generate_hash_value(msg, strlen(msg),
308 MEMCACHED_HASH_JENKINS);
309 assert(values[rc] == hash_val);
310 }
311
312 return 0;
313 }
314
315 static test_return set_test(memcached_st *memc)
316 {
317 memcached_return rc;
318 const char *key= "foo";
319 const char *value= "when we sanitize";
320
321 rc= memcached_set(memc, key, strlen(key),
322 value, strlen(value),
323 (time_t)0, (uint32_t)0);
324 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
325
326 return 0;
327 }
328
329 static test_return append_test(memcached_st *memc)
330 {
331 memcached_return rc;
332 const char *key= "fig";
333 const char *in_value= "we";
334 char *out_value= NULL;
335 size_t value_length;
336 uint32_t flags;
337
338 rc= memcached_flush(memc, 0);
339 assert(rc == MEMCACHED_SUCCESS);
340
341 rc= memcached_set(memc, key, strlen(key),
342 in_value, strlen(in_value),
343 (time_t)0, (uint32_t)0);
344 assert(rc == MEMCACHED_SUCCESS);
345
346 rc= memcached_append(memc, key, strlen(key),
347 " the", strlen(" the"),
348 (time_t)0, (uint32_t)0);
349 assert(rc == MEMCACHED_SUCCESS);
350
351 rc= memcached_append(memc, key, strlen(key),
352 " people", strlen(" people"),
353 (time_t)0, (uint32_t)0);
354 assert(rc == MEMCACHED_SUCCESS);
355
356 out_value= memcached_get(memc, key, strlen(key),
357 &value_length, &flags, &rc);
358 assert(!memcmp(out_value, "we the people", strlen("we the people")));
359 assert(strlen("we the people") == value_length);
360 assert(rc == MEMCACHED_SUCCESS);
361 free(out_value);
362
363 return 0;
364 }
365
366 static test_return append_binary_test(memcached_st *memc)
367 {
368 memcached_return rc;
369 const char *key= "numbers";
370 unsigned int *store_ptr;
371 unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
372 char *value;
373 size_t value_length;
374 uint32_t flags;
375 unsigned int x;
376
377 rc= memcached_flush(memc, 0);
378 assert(rc == MEMCACHED_SUCCESS);
379
380 rc= memcached_set(memc,
381 key, strlen(key),
382 NULL, 0,
383 (time_t)0, (uint32_t)0);
384 assert(rc == MEMCACHED_SUCCESS);
385
386 for (x= 0; store_list[x] ; x++)
387 {
388 rc= memcached_append(memc,
389 key, strlen(key),
390 (char *)&store_list[x], sizeof(unsigned int),
391 (time_t)0, (uint32_t)0);
392 assert(rc == MEMCACHED_SUCCESS);
393 }
394
395 value= memcached_get(memc, key, strlen(key),
396 &value_length, &flags, &rc);
397 assert((value_length == (sizeof(unsigned int) * x)));
398 assert(rc == MEMCACHED_SUCCESS);
399
400 store_ptr= (unsigned int *)value;
401 x= 0;
402 while ((size_t)store_ptr < (size_t)(value + value_length))
403 {
404 assert(*store_ptr == store_list[x++]);
405 store_ptr++;
406 }
407 free(value);
408
409 return 0;
410 }
411
412 static test_return cas2_test(memcached_st *memc)
413 {
414 memcached_return rc;
415 const char *keys[]= {"fudge", "son", "food"};
416 size_t key_length[]= {5, 3, 4};
417 const char *value= "we the people";
418 size_t value_length= strlen("we the people");
419 unsigned int x;
420 memcached_result_st results_obj;
421 memcached_result_st *results;
422 unsigned int set= 1;
423
424 rc= memcached_flush(memc, 0);
425 assert(rc == MEMCACHED_SUCCESS);
426
427 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
428
429 for (x= 0; x < 3; x++)
430 {
431 rc= memcached_set(memc, keys[x], key_length[x],
432 keys[x], key_length[x],
433 (time_t)50, (uint32_t)9);
434 assert(rc == MEMCACHED_SUCCESS);
435 }
436
437 rc= memcached_mget(memc, keys, key_length, 3);
438
439 results= memcached_result_create(memc, &results_obj);
440
441 results= memcached_fetch_result(memc, &results_obj, &rc);
442 assert(results);
443 assert(results->cas);
444 assert(rc == MEMCACHED_SUCCESS);
445 assert(memcached_result_cas(results));
446
447 assert(!memcmp(value, "we the people", strlen("we the people")));
448 assert(strlen("we the people") == value_length);
449 assert(rc == MEMCACHED_SUCCESS);
450
451 memcached_result_free(&results_obj);
452
453 return 0;
454 }
455
456 static test_return cas_test(memcached_st *memc)
457 {
458 memcached_return rc;
459 const char *key= "fun";
460 size_t key_length= strlen(key);
461 const char *value= "we the people";
462 const char* keys[2] = { key, NULL };
463 size_t keylengths[2] = { strlen(key), 0 };
464 size_t value_length= strlen(value);
465 const char *value2= "change the value";
466 size_t value2_length= strlen(value2);
467
468 memcached_result_st results_obj;
469 memcached_result_st *results;
470 unsigned int set= 1;
471
472 rc= memcached_flush(memc, 0);
473 assert(rc == MEMCACHED_SUCCESS);
474
475 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
476
477 rc= memcached_set(memc, key, strlen(key),
478 value, strlen(value),
479 (time_t)0, (uint32_t)0);
480 assert(rc == MEMCACHED_SUCCESS);
481
482 rc= memcached_mget(memc, keys, keylengths, 1);
483
484 results= memcached_result_create(memc, &results_obj);
485
486 results= memcached_fetch_result(memc, &results_obj, &rc);
487 assert(results);
488 assert(rc == MEMCACHED_SUCCESS);
489 assert(memcached_result_cas(results));
490 assert(!memcmp(value, memcached_result_value(results), value_length));
491 assert(strlen(memcached_result_value(results)) == value_length);
492 assert(rc == MEMCACHED_SUCCESS);
493 uint64_t cas = memcached_result_cas(results);
494
495 #if 0
496 results= memcached_fetch_result(memc, &results_obj, &rc);
497 assert(rc == MEMCACHED_END);
498 assert(results == NULL);
499 #endif
500
501 rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
502 assert(rc == MEMCACHED_SUCCESS);
503
504 /*
505 * The item will have a new cas value, so try to set it again with the old
506 * value. This should fail!
507 */
508 rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
509 assert(rc == MEMCACHED_DATA_EXISTS);
510
511 memcached_result_free(&results_obj);
512
513 return 0;
514 }
515
516 static test_return prepend_test(memcached_st *memc)
517 {
518 memcached_return rc;
519 const char *key= "fig";
520 const char *value= "people";
521 char *out_value= NULL;
522 size_t value_length;
523 uint32_t flags;
524
525 rc= memcached_flush(memc, 0);
526 assert(rc == MEMCACHED_SUCCESS);
527
528 rc= memcached_set(memc, key, strlen(key),
529 value, strlen(value),
530 (time_t)0, (uint32_t)0);
531 assert(rc == MEMCACHED_SUCCESS);
532
533 rc= memcached_prepend(memc, key, strlen(key),
534 "the ", strlen("the "),
535 (time_t)0, (uint32_t)0);
536 assert(rc == MEMCACHED_SUCCESS);
537
538 rc= memcached_prepend(memc, key, strlen(key),
539 "we ", strlen("we "),
540 (time_t)0, (uint32_t)0);
541 assert(rc == MEMCACHED_SUCCESS);
542
543 out_value= memcached_get(memc, key, strlen(key),
544 &value_length, &flags, &rc);
545 assert(!memcmp(out_value, "we the people", strlen("we the people")));
546 assert(strlen("we the people") == value_length);
547 assert(rc == MEMCACHED_SUCCESS);
548 free(out_value);
549
550 return 0;
551 }
552
553 /*
554 Set the value, then quit to make sure it is flushed.
555 Come back in and test that add fails.
556 */
557 static test_return add_test(memcached_st *memc)
558 {
559 memcached_return rc;
560 const char *key= "foo";
561 const char *value= "when we sanitize";
562 unsigned long long setting_value;
563
564 setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
565
566 rc= memcached_set(memc, key, strlen(key),
567 value, strlen(value),
568 (time_t)0, (uint32_t)0);
569 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
570 memcached_quit(memc);
571 rc= memcached_add(memc, key, strlen(key),
572 value, strlen(value),
573 (time_t)0, (uint32_t)0);
574
575 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
576 if (setting_value)
577 assert(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);
578 else
579 assert(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_DATA_EXISTS);
580
581 return 0;
582 }
583
584 /*
585 ** There was a problem of leaking filedescriptors in the initial release
586 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
587 ** systems it seems that the kernel is slow on reclaiming the resources
588 ** because the connects starts to time out (the test doesn't do much
589 ** anyway, so just loop 10 iterations)
590 */
591 static test_return add_wrapper(memcached_st *memc)
592 {
593 unsigned int x;
594 unsigned int max= 10000;
595 #ifdef __sun
596 max= 10;
597 #endif
598
599 for (x= 0; x < max; x++)
600 add_test(memc);
601
602 return 0;
603 }
604
605 static test_return replace_test(memcached_st *memc)
606 {
607 memcached_return rc;
608 const char *key= "foo";
609 const char *value= "when we sanitize";
610 const char *original= "first we insert some data";
611
612 rc= memcached_set(memc, key, strlen(key),
613 original, strlen(original),
614 (time_t)0, (uint32_t)0);
615 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
616
617 rc= memcached_replace(memc, key, strlen(key),
618 value, strlen(value),
619 (time_t)0, (uint32_t)0);
620 assert(rc == MEMCACHED_SUCCESS);
621
622 return 0;
623 }
624
625 static test_return delete_test(memcached_st *memc)
626 {
627 memcached_return rc;
628 const char *key= "foo";
629 const char *value= "when we sanitize";
630
631 rc= memcached_set(memc, key, strlen(key),
632 value, strlen(value),
633 (time_t)0, (uint32_t)0);
634 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
635
636 rc= memcached_delete(memc, key, strlen(key), (time_t)0);
637 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
638
639 return 0;
640 }
641
642 static test_return flush_test(memcached_st *memc)
643 {
644 memcached_return rc;
645
646 rc= memcached_flush(memc, 0);
647 assert(rc == MEMCACHED_SUCCESS);
648
649 return 0;
650 }
651
652 static memcached_return server_function(memcached_st *ptr __attribute__((unused)),
653 memcached_server_st *server __attribute__((unused)),
654 void *context __attribute__((unused)))
655 {
656 /* Do Nothing */
657
658 return MEMCACHED_SUCCESS;
659 }
660
661 static test_return memcached_server_cursor_test(memcached_st *memc)
662 {
663 char context[8];
664 strcpy(context, "foo bad");
665 memcached_server_function callbacks[1];
666
667 callbacks[0]= server_function;
668 memcached_server_cursor(memc, callbacks, context, 1);
669 return 0;
670 }
671
672 static test_return bad_key_test(memcached_st *memc)
673 {
674 memcached_return rc;
675 const char *key= "foo bad";
676 char *string;
677 size_t string_length;
678 uint32_t flags;
679 memcached_st *memc_clone;
680 unsigned int set= 1;
681 size_t max_keylen= 0xffff;
682
683 memc_clone= memcached_clone(NULL, memc);
684 assert(memc_clone);
685
686 rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
687 assert(rc == MEMCACHED_SUCCESS);
688
689 /* All keys are valid in the binary protocol (except for length) */
690 if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0)
691 {
692 string= memcached_get(memc_clone, key, strlen(key),
693 &string_length, &flags, &rc);
694 assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
695 assert(string_length == 0);
696 assert(!string);
697
698 set= 0;
699 rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
700 assert(rc == MEMCACHED_SUCCESS);
701 string= memcached_get(memc_clone, key, strlen(key),
702 &string_length, &flags, &rc);
703 assert(rc == MEMCACHED_NOTFOUND);
704 assert(string_length == 0);
705 assert(!string);
706
707 /* Test multi key for bad keys */
708 const char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
709 size_t key_lengths[] = { 7, 7, 7 };
710 set= 1;
711 rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
712 assert(rc == MEMCACHED_SUCCESS);
713
714 rc= memcached_mget(memc_clone, keys, key_lengths, 3);
715 assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
716
717 rc= memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1);
718 assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
719
720 max_keylen= 250;
721
722 /* The following test should be moved to the end of this function when the
723 memcached server is updated to allow max size length of the keys in the
724 binary protocol
725 */
726 rc= memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
727 assert(rc == MEMCACHED_SUCCESS);
728
729 char *longkey= malloc(max_keylen + 1);
730 if (longkey != NULL)
731 {
732 memset(longkey, 'a', max_keylen + 1);
733 string= memcached_get(memc_clone, longkey, max_keylen,
734 &string_length, &flags, &rc);
735 assert(rc == MEMCACHED_NOTFOUND);
736 assert(string_length == 0);
737 assert(!string);
738
739 string= memcached_get(memc_clone, longkey, max_keylen + 1,
740 &string_length, &flags, &rc);
741 assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
742 assert(string_length == 0);
743 assert(!string);
744
745 free(longkey);
746 }
747 }
748
749 /* Make sure zero length keys are marked as bad */
750 set= 1;
751 rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
752 assert(rc == MEMCACHED_SUCCESS);
753 string= memcached_get(memc_clone, key, 0,
754 &string_length, &flags, &rc);
755 assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
756 assert(string_length == 0);
757 assert(!string);
758
759 memcached_free(memc_clone);
760
761 return 0;
762 }
763
764 #define READ_THROUGH_VALUE "set for me"
765 static memcached_return read_through_trigger(memcached_st *memc __attribute__((unused)),
766 char *key __attribute__((unused)),
767 size_t key_length __attribute__((unused)),
768 memcached_result_st *result)
769 {
770
771 return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
772 }
773
774 static test_return read_through(memcached_st *memc)
775 {
776 memcached_return rc;
777 const char *key= "foo";
778 char *string;
779 size_t string_length;
780 uint32_t flags;
781 memcached_trigger_key cb= (memcached_trigger_key)read_through_trigger;
782
783 string= memcached_get(memc, key, strlen(key),
784 &string_length, &flags, &rc);
785
786 assert(rc == MEMCACHED_NOTFOUND);
787 assert(string_length == 0);
788 assert(!string);
789
790 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE,
791 *(void **)&cb);
792 assert(rc == MEMCACHED_SUCCESS);
793
794 string= memcached_get(memc, key, strlen(key),
795 &string_length, &flags, &rc);
796
797 assert(rc == MEMCACHED_SUCCESS);
798 assert(string_length == strlen(READ_THROUGH_VALUE));
799 assert(!strcmp(READ_THROUGH_VALUE, string));
800 free(string);
801
802 string= memcached_get(memc, key, strlen(key),
803 &string_length, &flags, &rc);
804
805 assert(rc == MEMCACHED_SUCCESS);
806 assert(string_length == strlen(READ_THROUGH_VALUE));
807 assert(!strcmp(READ_THROUGH_VALUE, string));
808 free(string);
809
810 return 0;
811 }
812
813 static memcached_return delete_trigger(memcached_st *ptr __attribute__((unused)),
814 const char *key,
815 size_t key_length __attribute__((unused)))
816 {
817 assert(key);
818
819 return MEMCACHED_SUCCESS;
820 }
821
822 static test_return delete_through(memcached_st *memc)
823 {
824 memcached_trigger_delete_key callback;
825 memcached_return rc;
826
827 callback= (memcached_trigger_delete_key)delete_trigger;
828
829 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, *(void**)&callback);
830 assert(rc == MEMCACHED_SUCCESS);
831
832 return 0;
833 }
834
835 static test_return get_test(memcached_st *memc)
836 {
837 memcached_return rc;
838 const char *key= "foo";
839 char *string;
840 size_t string_length;
841 uint32_t flags;
842
843 rc= memcached_delete(memc, key, strlen(key), (time_t)0);
844 assert(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);
845
846 string= memcached_get(memc, key, strlen(key),
847 &string_length, &flags, &rc);
848
849 assert(rc == MEMCACHED_NOTFOUND);
850 assert(string_length == 0);
851 assert(!string);
852
853 return 0;
854 }
855
856 static test_return get_test2(memcached_st *memc)
857 {
858 memcached_return rc;
859 const char *key= "foo";
860 const char *value= "when we sanitize";
861 char *string;
862 size_t string_length;
863 uint32_t flags;
864
865 rc= memcached_set(memc, key, strlen(key),
866 value, strlen(value),
867 (time_t)0, (uint32_t)0);
868 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
869
870 string= memcached_get(memc, key, strlen(key),
871 &string_length, &flags, &rc);
872
873 assert(string);
874 assert(rc == MEMCACHED_SUCCESS);
875 assert(string_length == strlen(value));
876 assert(!memcmp(string, value, string_length));
877
878 free(string);
879
880 return 0;
881 }
882
883 static test_return set_test2(memcached_st *memc)
884 {
885 memcached_return rc;
886 const char *key= "foo";
887 const char *value= "train in the brain";
888 size_t value_length= strlen(value);
889 unsigned int x;
890
891 for (x= 0; x < 10; x++)
892 {
893 rc= memcached_set(memc, key, strlen(key),
894 value, value_length,
895 (time_t)0, (uint32_t)0);
896 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
897 }
898
899 return 0;
900 }
901
902 static test_return set_test3(memcached_st *memc)
903 {
904 memcached_return rc;
905 char *value;
906 size_t value_length= 8191;
907 unsigned int x;
908
909 value = (char*)malloc(value_length);
910 assert(value);
911
912 for (x= 0; x < value_length; x++)
913 value[x] = (char) (x % 127);
914
915 /* The dump test relies on there being at least 32 items in memcached */
916 for (x= 0; x < 32; x++)
917 {
918 char key[16];
919
920 sprintf(key, "foo%u", x);
921
922 rc= memcached_set(memc, key, strlen(key),
923 value, value_length,
924 (time_t)0, (uint32_t)0);
925 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
926 }
927
928 free(value);
929
930 return 0;
931 }
932
933 static test_return get_test3(memcached_st *memc)
934 {
935 memcached_return rc;
936 const char *key= "foo";
937 char *value;
938 size_t value_length= 8191;
939 char *string;
940 size_t string_length;
941 uint32_t flags;
942 uint32_t x;
943
944 value = (char*)malloc(value_length);
945 assert(value);
946
947 for (x= 0; x < value_length; x++)
948 value[x] = (char) (x % 127);
949
950 rc= memcached_set(memc, key, strlen(key),
951 value, value_length,
952 (time_t)0, (uint32_t)0);
953 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
954
955 string= memcached_get(memc, key, strlen(key),
956 &string_length, &flags, &rc);
957
958 assert(rc == MEMCACHED_SUCCESS);
959 assert(string);
960 assert(string_length == value_length);
961 assert(!memcmp(string, value, string_length));
962
963 free(string);
964 free(value);
965
966 return 0;
967 }
968
969 static test_return get_test4(memcached_st *memc)
970 {
971 memcached_return rc;
972 const char *key= "foo";
973 char *value;
974 size_t value_length= 8191;
975 char *string;
976 size_t string_length;
977 uint32_t flags;
978 uint32_t x;
979
980 value = (char*)malloc(value_length);
981 assert(value);
982
983 for (x= 0; x < value_length; x++)
984 value[x] = (char) (x % 127);
985
986 rc= memcached_set(memc, key, strlen(key),
987 value, value_length,
988 (time_t)0, (uint32_t)0);
989 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
990
991 for (x= 0; x < 10; x++)
992 {
993 string= memcached_get(memc, key, strlen(key),
994 &string_length, &flags, &rc);
995
996 assert(rc == MEMCACHED_SUCCESS);
997 assert(string);
998 assert(string_length == value_length);
999 assert(!memcmp(string, value, string_length));
1000 free(string);
1001 }
1002
1003 free(value);
1004
1005 return 0;
1006 }
1007
1008 /*
1009 * This test verifies that memcached_read_one_response doesn't try to
1010 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1011 * responses before you execute a storage command.
1012 */
1013 static test_return get_test5(memcached_st *memc)
1014 {
1015 /*
1016 ** Request the same key twice, to ensure that we hash to the same server
1017 ** (so that we have multiple response values queued up) ;-)
1018 */
1019 const char *keys[]= { "key", "key" };
1020 size_t lengths[]= { 3, 3 };
1021 uint32_t flags;
1022 size_t rlen;
1023
1024 memcached_return rc= memcached_set(memc, keys[0], lengths[0],
1025 keys[0], lengths[0], 0, 0);
1026 assert(rc == MEMCACHED_SUCCESS);
1027 rc= memcached_mget(memc, keys, lengths, 2);
1028
1029 memcached_result_st results_obj;
1030 memcached_result_st *results;
1031 results=memcached_result_create(memc, &results_obj);
1032 assert(results);
1033 results=memcached_fetch_result(memc, &results_obj, &rc);
1034 assert(results);
1035 memcached_result_free(&results_obj);
1036
1037 /* Don't read out the second result, but issue a set instead.. */
1038 rc= memcached_set(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0);
1039 assert(rc == MEMCACHED_SUCCESS);
1040
1041 char *val= memcached_get_by_key(memc, keys[0], lengths[0], "yek", 3,
1042 &rlen, &flags, &rc);
1043 assert(val == NULL);
1044 assert(rc == MEMCACHED_NOTFOUND);
1045 val= memcached_get(memc, keys[0], lengths[0], &rlen, &flags, &rc);
1046 assert(val != NULL);
1047 assert(rc == MEMCACHED_SUCCESS);
1048 free(val);
1049
1050 return TEST_SUCCESS;
1051 }
1052
1053 /* Do not copy the style of this code, I just access hosts to testthis function */
1054 static test_return stats_servername_test(memcached_st *memc)
1055 {
1056 memcached_return rc;
1057 memcached_stat_st memc_stat;
1058 rc= memcached_stat_servername(&memc_stat, NULL,
1059 memc->hosts[0].hostname,
1060 memc->hosts[0].port);
1061
1062 return 0;
1063 }
1064
1065 static test_return increment_test(memcached_st *memc)
1066 {
1067 uint64_t new_number;
1068 memcached_return rc;
1069 const char *key= "number";
1070 const char *value= "0";
1071
1072 rc= memcached_set(memc, key, strlen(key),
1073 value, strlen(value),
1074 (time_t)0, (uint32_t)0);
1075 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1076
1077 rc= memcached_increment(memc, key, strlen(key),
1078 1, &new_number);
1079 assert(rc == MEMCACHED_SUCCESS);
1080 assert(new_number == 1);
1081
1082 rc= memcached_increment(memc, key, strlen(key),
1083 1, &new_number);
1084 assert(rc == MEMCACHED_SUCCESS);
1085 assert(new_number == 2);
1086
1087 return 0;
1088 }
1089
1090 static test_return increment_with_initial_test(memcached_st *memc)
1091 {
1092 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1093 {
1094 uint64_t new_number;
1095 memcached_return rc;
1096 const char *key= "number";
1097 uint64_t initial= 0;
1098
1099 rc= memcached_increment_with_initial(memc, key, strlen(key),
1100 1, initial, 0, &new_number);
1101 assert(rc == MEMCACHED_SUCCESS);
1102 assert(new_number == initial);
1103
1104 rc= memcached_increment_with_initial(memc, key, strlen(key),
1105 1, initial, 0, &new_number);
1106 assert(rc == MEMCACHED_SUCCESS);
1107 assert(new_number == (initial + 1));
1108 }
1109 return 0;
1110 }
1111
1112 static test_return decrement_test(memcached_st *memc)
1113 {
1114 uint64_t new_number;
1115 memcached_return rc;
1116 const char *key= "number";
1117 const char *value= "3";
1118
1119 rc= memcached_set(memc, key, strlen(key),
1120 value, strlen(value),
1121 (time_t)0, (uint32_t)0);
1122 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1123
1124 rc= memcached_decrement(memc, key, strlen(key),
1125 1, &new_number);
1126 assert(rc == MEMCACHED_SUCCESS);
1127 assert(new_number == 2);
1128
1129 rc= memcached_decrement(memc, key, strlen(key),
1130 1, &new_number);
1131 assert(rc == MEMCACHED_SUCCESS);
1132 assert(new_number == 1);
1133
1134 return 0;
1135 }
1136
1137 static test_return decrement_with_initial_test(memcached_st *memc)
1138 {
1139 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1140 {
1141 uint64_t new_number;
1142 memcached_return rc;
1143 const char *key= "number";
1144 uint64_t initial= 3;
1145
1146 rc= memcached_decrement_with_initial(memc, key, strlen(key),
1147 1, initial, 0, &new_number);
1148 assert(rc == MEMCACHED_SUCCESS);
1149 assert(new_number == initial);
1150
1151 rc= memcached_decrement_with_initial(memc, key, strlen(key),
1152 1, initial, 0, &new_number);
1153 assert(rc == MEMCACHED_SUCCESS);
1154 assert(new_number == (initial - 1));
1155 }
1156 return 0;
1157 }
1158
1159 static test_return quit_test(memcached_st *memc)
1160 {
1161 memcached_return rc;
1162 const char *key= "fudge";
1163 const char *value= "sanford and sun";
1164
1165 rc= memcached_set(memc, key, strlen(key),
1166 value, strlen(value),
1167 (time_t)10, (uint32_t)3);
1168 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1169 memcached_quit(memc);
1170
1171 rc= memcached_set(memc, key, strlen(key),
1172 value, strlen(value),
1173 (time_t)50, (uint32_t)9);
1174 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1175
1176 return 0;
1177 }
1178
1179 static test_return mget_result_test(memcached_st *memc)
1180 {
1181 memcached_return rc;
1182 const char *keys[]= {"fudge", "son", "food"};
1183 size_t key_length[]= {5, 3, 4};
1184 unsigned int x;
1185
1186 memcached_result_st results_obj;
1187 memcached_result_st *results;
1188
1189 results= memcached_result_create(memc, &results_obj);
1190 assert(results);
1191 assert(&results_obj == results);
1192
1193 /* We need to empty the server before continueing test */
1194 rc= memcached_flush(memc, 0);
1195 assert(rc == MEMCACHED_SUCCESS);
1196
1197 rc= memcached_mget(memc, keys, key_length, 3);
1198 assert(rc == MEMCACHED_SUCCESS);
1199
1200 while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
1201 {
1202 assert(results);
1203 }
1204
1205 while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
1206 assert(!results);
1207 assert(rc == MEMCACHED_END);
1208
1209 for (x= 0; x < 3; x++)
1210 {
1211 rc= memcached_set(memc, keys[x], key_length[x],
1212 keys[x], key_length[x],
1213 (time_t)50, (uint32_t)9);
1214 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1215 }
1216
1217 rc= memcached_mget(memc, keys, key_length, 3);
1218 assert(rc == MEMCACHED_SUCCESS);
1219
1220 while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1221 {
1222 assert(results);
1223 assert(&results_obj == results);
1224 assert(rc == MEMCACHED_SUCCESS);
1225 assert(memcached_result_key_length(results) == memcached_result_length(results));
1226 assert(!memcmp(memcached_result_key_value(results),
1227 memcached_result_value(results),
1228 memcached_result_length(results)));
1229 }
1230
1231 memcached_result_free(&results_obj);
1232
1233 return 0;
1234 }
1235
1236 static test_return mget_result_alloc_test(memcached_st *memc)
1237 {
1238 memcached_return rc;
1239 const char *keys[]= {"fudge", "son", "food"};
1240 size_t key_length[]= {5, 3, 4};
1241 unsigned int x;
1242
1243 memcached_result_st *results;
1244
1245 /* We need to empty the server before continueing test */
1246 rc= memcached_flush(memc, 0);
1247 assert(rc == MEMCACHED_SUCCESS);
1248
1249 rc= memcached_mget(memc, keys, key_length, 3);
1250 assert(rc == MEMCACHED_SUCCESS);
1251
1252 while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
1253 {
1254 assert(results);
1255 }
1256 assert(!results);
1257 assert(rc == MEMCACHED_END);
1258
1259 for (x= 0; x < 3; x++)
1260 {
1261 rc= memcached_set(memc, keys[x], key_length[x],
1262 keys[x], key_length[x],
1263 (time_t)50, (uint32_t)9);
1264 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1265 }
1266
1267 rc= memcached_mget(memc, keys, key_length, 3);
1268 assert(rc == MEMCACHED_SUCCESS);
1269
1270 x= 0;
1271 while ((results= memcached_fetch_result(memc, NULL, &rc)))
1272 {
1273 assert(results);
1274 assert(rc == MEMCACHED_SUCCESS);
1275 assert(memcached_result_key_length(results) == memcached_result_length(results));
1276 assert(!memcmp(memcached_result_key_value(results),
1277 memcached_result_value(results),
1278 memcached_result_length(results)));
1279 memcached_result_free(results);
1280 x++;
1281 }
1282
1283 return 0;
1284 }
1285
1286 /* Count the results */
1287 static memcached_return callback_counter(memcached_st *ptr __attribute__((unused)),
1288 memcached_result_st *result __attribute__((unused)),
1289 void *context)
1290 {
1291 unsigned int *counter= (unsigned int *)context;
1292
1293 *counter= *counter + 1;
1294
1295 return MEMCACHED_SUCCESS;
1296 }
1297
1298 static test_return mget_result_function(memcached_st *memc)
1299 {
1300 memcached_return rc;
1301 const char *keys[]= {"fudge", "son", "food"};
1302 size_t key_length[]= {5, 3, 4};
1303 unsigned int x;
1304 unsigned int counter;
1305 memcached_execute_function callbacks[1];
1306
1307 /* We need to empty the server before continueing test */
1308 rc= memcached_flush(memc, 0);
1309 for (x= 0; x < 3; x++)
1310 {
1311 rc= memcached_set(memc, keys[x], key_length[x],
1312 keys[x], key_length[x],
1313 (time_t)50, (uint32_t)9);
1314 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1315 }
1316
1317 rc= memcached_mget(memc, keys, key_length, 3);
1318 assert(rc == MEMCACHED_SUCCESS);
1319
1320 callbacks[0]= &callback_counter;
1321 counter= 0;
1322 rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
1323
1324 assert(counter == 3);
1325
1326 return 0;
1327 }
1328
1329 static test_return mget_test(memcached_st *memc)
1330 {
1331 memcached_return rc;
1332 const char *keys[]= {"fudge", "son", "food"};
1333 size_t key_length[]= {5, 3, 4};
1334 unsigned int x;
1335 uint32_t flags;
1336
1337 char return_key[MEMCACHED_MAX_KEY];
1338 size_t return_key_length;
1339 char *return_value;
1340 size_t return_value_length;
1341
1342 /* We need to empty the server before continueing test */
1343 rc= memcached_flush(memc, 0);
1344 assert(rc == MEMCACHED_SUCCESS);
1345
1346 rc= memcached_mget(memc, keys, key_length, 3);
1347 assert(rc == MEMCACHED_SUCCESS);
1348
1349 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1350 &return_value_length, &flags, &rc)) != NULL)
1351 {
1352 assert(return_value);
1353 }
1354 assert(!return_value);
1355 assert(return_value_length == 0);
1356 assert(rc == MEMCACHED_END);
1357
1358 for (x= 0; x < 3; x++)
1359 {
1360 rc= memcached_set(memc, keys[x], key_length[x],
1361 keys[x], key_length[x],
1362 (time_t)50, (uint32_t)9);
1363 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1364 }
1365
1366 rc= memcached_mget(memc, keys, key_length, 3);
1367 assert(rc == MEMCACHED_SUCCESS);
1368
1369 x= 0;
1370 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1371 &return_value_length, &flags, &rc)))
1372 {
1373 assert(return_value);
1374 assert(rc == MEMCACHED_SUCCESS);
1375 assert(return_key_length == return_value_length);
1376 assert(!memcmp(return_value, return_key, return_value_length));
1377 free(return_value);
1378 x++;
1379 }
1380
1381 return 0;
1382 }
1383
1384 static test_return get_stats_keys(memcached_st *memc)
1385 {
1386 char **list;
1387 char **ptr;
1388 memcached_stat_st memc_stat;
1389 memcached_return rc;
1390
1391 list= memcached_stat_get_keys(memc, &memc_stat, &rc);
1392 assert(rc == MEMCACHED_SUCCESS);
1393 for (ptr= list; *ptr; ptr++)
1394 assert(*ptr);
1395 fflush(stdout);
1396
1397 free(list);
1398
1399 return 0;
1400 }
1401
1402 static test_return version_string_test(memcached_st *memc __attribute__((unused)))
1403 {
1404 const char *version_string;
1405
1406 version_string= memcached_lib_version();
1407
1408 assert(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING));
1409
1410 return 0;
1411 }
1412
1413 static test_return get_stats(memcached_st *memc)
1414 {
1415 unsigned int x;
1416 char **list;
1417 char **ptr;
1418 memcached_return rc;
1419 memcached_stat_st *memc_stat;
1420
1421 memc_stat= memcached_stat(memc, NULL, &rc);
1422 assert(rc == MEMCACHED_SUCCESS);
1423
1424 assert(rc == MEMCACHED_SUCCESS);
1425 assert(memc_stat);
1426
1427 for (x= 0; x < memcached_server_count(memc); x++)
1428 {
1429 list= memcached_stat_get_keys(memc, memc_stat+x, &rc);
1430 assert(rc == MEMCACHED_SUCCESS);
1431 for (ptr= list; *ptr; ptr++);
1432
1433 free(list);
1434 }
1435
1436 memcached_stat_free(NULL, memc_stat);
1437
1438 return 0;
1439 }
1440
1441 static test_return add_host_test(memcached_st *memc)
1442 {
1443 unsigned int x;
1444 memcached_server_st *servers;
1445 memcached_return rc;
1446 char servername[]= "0.example.com";
1447
1448 servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
1449 assert(servers);
1450 assert(1 == memcached_server_list_count(servers));
1451
1452 for (x= 2; x < 20; x++)
1453 {
1454 char buffer[SMALL_STRING_LEN];
1455
1456 snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1457 servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
1458 &rc);
1459 assert(rc == MEMCACHED_SUCCESS);
1460 assert(x == memcached_server_list_count(servers));
1461 }
1462
1463 rc= memcached_server_push(memc, servers);
1464 assert(rc == MEMCACHED_SUCCESS);
1465 rc= memcached_server_push(memc, servers);
1466 assert(rc == MEMCACHED_SUCCESS);
1467
1468 memcached_server_list_free(servers);
1469
1470 return 0;
1471 }
1472
1473 static memcached_return clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *memc_clone __attribute__((unused)))
1474 {
1475 return MEMCACHED_SUCCESS;
1476 }
1477
1478 static memcached_return cleanup_test_callback(memcached_st *ptr __attribute__((unused)))
1479 {
1480 return MEMCACHED_SUCCESS;
1481 }
1482
1483 static test_return callback_test(memcached_st *memc)
1484 {
1485 /* Test User Data */
1486 {
1487 int x= 5;
1488 int *test_ptr;
1489 memcached_return rc;
1490
1491 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x);
1492 assert(rc == MEMCACHED_SUCCESS);
1493 test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
1494 assert(*test_ptr == x);
1495 }
1496
1497 /* Test Clone Callback */
1498 {
1499 memcached_clone_func clone_cb= (memcached_clone_func)clone_test_callback;
1500 void *clone_cb_ptr= *(void **)&clone_cb;
1501 void *temp_function= NULL;
1502 memcached_return rc;
1503
1504 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION,
1505 clone_cb_ptr);
1506 assert(rc == MEMCACHED_SUCCESS);
1507 temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1508 assert(temp_function == clone_cb_ptr);
1509 }
1510
1511 /* Test Cleanup Callback */
1512 {
1513 memcached_cleanup_func cleanup_cb=
1514 (memcached_cleanup_func)cleanup_test_callback;
1515 void *cleanup_cb_ptr= *(void **)&cleanup_cb;
1516 void *temp_function= NULL;
1517 memcached_return rc;
1518
1519 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION,
1520 cleanup_cb_ptr);
1521 assert(rc == MEMCACHED_SUCCESS);
1522 temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1523 assert(temp_function == cleanup_cb_ptr);
1524 }
1525
1526 return 0;
1527 }
1528
1529 /* We don't test the behavior itself, we test the switches */
1530 static test_return behavior_test(memcached_st *memc)
1531 {
1532 uint64_t value;
1533 uint32_t set= 1;
1534
1535 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1536 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1537 assert(value == 1);
1538
1539 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1540 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1541 assert(value == 1);
1542
1543 set= MEMCACHED_HASH_MD5;
1544 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1545 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1546 assert(value == MEMCACHED_HASH_MD5);
1547
1548 set= 0;
1549
1550 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1551 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1552 assert(value == 0);
1553
1554 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1555 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1556 assert(value == 0);
1557
1558 set= MEMCACHED_HASH_DEFAULT;
1559 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1560 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1561 assert(value == MEMCACHED_HASH_DEFAULT);
1562
1563 set= MEMCACHED_HASH_CRC;
1564 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1565 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1566 assert(value == MEMCACHED_HASH_CRC);
1567
1568 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1569 assert(value > 0);
1570
1571 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1572 assert(value > 0);
1573
1574 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
1575 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value + 1);
1576 assert((value + 1) == memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));
1577 return 0;
1578 }
1579
1580 /* Test case provided by Cal Haldenbrand */
1581 static test_return user_supplied_bug1(memcached_st *memc)
1582 {
1583 unsigned int setter= 1;
1584 unsigned int x;
1585
1586 unsigned long long total= 0;
1587 uint32_t size= 0;
1588 char key[10];
1589 char randomstuff[6 * 1024];
1590 memcached_return rc;
1591
1592 memset(randomstuff, 0, 6 * 1024);
1593
1594 /* We just keep looking at the same values over and over */
1595 srandom(10);
1596
1597 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1598 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1599
1600
1601 /* add key */
1602 for (x= 0 ; total < 20 * 1024576 ; x++ )
1603 {
1604 unsigned int j= 0;
1605
1606 size= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
1607 memset(randomstuff, 0, 6 * 1024);
1608 assert(size < 6 * 1024); /* Being safe here */
1609
1610 for (j= 0 ; j < size ;j++)
1611 randomstuff[j] = (signed char) ((rand() % 26) + 97);
1612
1613 total += size;
1614 sprintf(key, "%d", x);
1615 rc = memcached_set(memc, key, strlen(key),
1616 randomstuff, strlen(randomstuff), 10, 0);
1617 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1618 /* If we fail, lets try again */
1619 if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
1620 rc = memcached_set(memc, key, strlen(key),
1621 randomstuff, strlen(randomstuff), 10, 0);
1622 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1623 }
1624
1625 return 0;
1626 }
1627
1628 /* Test case provided by Cal Haldenbrand */
1629 static test_return user_supplied_bug2(memcached_st *memc)
1630 {
1631 int errors;
1632 unsigned int setter;
1633 unsigned int x;
1634 unsigned long long total;
1635
1636 setter= 1;
1637 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1638 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1639 #ifdef NOT_YET
1640 setter = 20 * 1024576;
1641 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
1642 setter = 20 * 1024576;
1643 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
1644 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1645 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1646
1647 for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
1648 #endif
1649
1650 for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
1651 {
1652 memcached_return rc= MEMCACHED_SUCCESS;
1653 char buffer[SMALL_STRING_LEN];
1654 uint32_t flags= 0;
1655 size_t val_len= 0;
1656 char *getval;
1657
1658 memset(buffer, 0, SMALL_STRING_LEN);
1659
1660 snprintf(buffer, SMALL_STRING_LEN, "%u", x);
1661 getval= memcached_get(memc, buffer, strlen(buffer),
1662 &val_len, &flags, &rc);
1663 if (rc != MEMCACHED_SUCCESS)
1664 {
1665 if (rc == MEMCACHED_NOTFOUND)
1666 errors++;
1667 else
1668 {
1669 assert(rc);
1670 }
1671
1672 continue;
1673 }
1674 total+= val_len;
1675 errors= 0;
1676 free(getval);
1677 }
1678
1679 return 0;
1680 }
1681
1682 /* Do a large mget() over all the keys we think exist */
1683 #define KEY_COUNT 3000 // * 1024576
1684 static test_return user_supplied_bug3(memcached_st *memc)
1685 {
1686 memcached_return rc;
1687 unsigned int setter;
1688 unsigned int x;
1689 char **keys;
1690 size_t key_lengths[KEY_COUNT];
1691
1692 setter= 1;
1693 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1694 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1695 #ifdef NOT_YET
1696 setter = 20 * 1024576;
1697 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
1698 setter = 20 * 1024576;
1699 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
1700 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1701 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1702 #endif
1703
1704 keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
1705 assert(keys);
1706 memset(keys, 0, (sizeof(char *) * KEY_COUNT));
1707 for (x= 0; x < KEY_COUNT; x++)
1708 {
1709 char buffer[30];
1710
1711 snprintf(buffer, 30, "%u", x);
1712 keys[x]= strdup(buffer);
1713 key_lengths[x]= strlen(keys[x]);
1714 }
1715
1716 rc= memcached_mget(memc, (const char **)keys, key_lengths, KEY_COUNT);
1717 assert(rc == MEMCACHED_SUCCESS);
1718
1719 /* Turn this into a help function */
1720 {
1721 char return_key[MEMCACHED_MAX_KEY];
1722 size_t return_key_length;
1723 char *return_value;
1724 size_t return_value_length;
1725 uint32_t flags;
1726
1727 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1728 &return_value_length, &flags, &rc)))
1729 {
1730 assert(return_value);
1731 assert(rc == MEMCACHED_SUCCESS);
1732 free(return_value);
1733 }
1734 }
1735
1736 for (x= 0; x < KEY_COUNT; x++)
1737 free(keys[x]);
1738 free(keys);
1739
1740 return 0;
1741 }
1742
1743 /* Make sure we behave properly if server list has no values */
1744 static test_return user_supplied_bug4(memcached_st *memc)
1745 {
1746 memcached_return rc;
1747 const char *keys[]= {"fudge", "son", "food"};
1748 size_t key_length[]= {5, 3, 4};
1749 unsigned int x;
1750 uint32_t flags;
1751 char return_key[MEMCACHED_MAX_KEY];
1752 size_t return_key_length;
1753 char *return_value;
1754 size_t return_value_length;
1755
1756 /* Here we free everything before running a bunch of mget tests */
1757 {
1758 memcached_server_list_free(memc->hosts);
1759 memc->hosts= NULL;
1760 memc->number_of_hosts= 0;
1761 }
1762
1763
1764 /* We need to empty the server before continueing test */
1765 rc= memcached_flush(memc, 0);
1766 assert(rc == MEMCACHED_NO_SERVERS);
1767
1768 rc= memcached_mget(memc, keys, key_length, 3);
1769 assert(rc == MEMCACHED_NO_SERVERS);
1770
1771 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1772 &return_value_length, &flags, &rc)) != NULL)
1773 {
1774 assert(return_value);
1775 }
1776 assert(!return_value);
1777 assert(return_value_length == 0);
1778 assert(rc == MEMCACHED_NO_SERVERS);
1779
1780 for (x= 0; x < 3; x++)
1781 {
1782 rc= memcached_set(memc, keys[x], key_length[x],
1783 keys[x], key_length[x],
1784 (time_t)50, (uint32_t)9);
1785 assert(rc == MEMCACHED_NO_SERVERS);
1786 }
1787
1788 rc= memcached_mget(memc, keys, key_length, 3);
1789 assert(rc == MEMCACHED_NO_SERVERS);
1790
1791 x= 0;
1792 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1793 &return_value_length, &flags, &rc)))
1794 {
1795 assert(return_value);
1796 assert(rc == MEMCACHED_SUCCESS);
1797 assert(return_key_length == return_value_length);
1798 assert(!memcmp(return_value, return_key, return_value_length));
1799 free(return_value);
1800 x++;
1801 }
1802
1803 return 0;
1804 }
1805
1806 #define VALUE_SIZE_BUG5 1048064
1807 static test_return user_supplied_bug5(memcached_st *memc)
1808 {
1809 memcached_return rc;
1810 const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1811 size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1812 char return_key[MEMCACHED_MAX_KEY];
1813 size_t return_key_length;
1814 char *value;
1815 size_t value_length;
1816 uint32_t flags;
1817 unsigned int count;
1818 unsigned int x;
1819 char insert_data[VALUE_SIZE_BUG5];
1820
1821 for (x= 0; x < VALUE_SIZE_BUG5; x++)
1822 insert_data[x]= (signed char)rand();
1823
1824 memcached_flush(memc, 0);
1825 value= memcached_get(memc, keys[0], key_length[0],
1826 &value_length, &flags, &rc);
1827 assert(value == NULL);
1828 rc= memcached_mget(memc, keys, key_length, 4);
1829
1830 count= 0;
1831 while ((value= memcached_fetch(memc, return_key, &return_key_length,
1832 &value_length, &flags, &rc)))
1833 count++;
1834 assert(count == 0);
1835
1836 for (x= 0; x < 4; x++)
1837 {
1838 rc= memcached_set(memc, keys[x], key_length[x],
1839 insert_data, VALUE_SIZE_BUG5,
1840 (time_t)0, (uint32_t)0);
1841 assert(rc == MEMCACHED_SUCCESS);
1842 }
1843
1844 for (x= 0; x < 10; x++)
1845 {
1846 value= memcached_get(memc, keys[0], key_length[0],
1847 &value_length, &flags, &rc);
1848 assert(value);
1849 free(value);
1850
1851 rc= memcached_mget(memc, keys, key_length, 4);
1852 count= 0;
1853 while ((value= memcached_fetch(memc, return_key, &return_key_length,
1854 &value_length, &flags, &rc)))
1855 {
1856 count++;
1857 free(value);
1858 }
1859 assert(count == 4);
1860 }
1861
1862 return 0;
1863 }
1864
1865 static test_return user_supplied_bug6(memcached_st *memc)
1866 {
1867 memcached_return rc;
1868 const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1869 size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1870 char return_key[MEMCACHED_MAX_KEY];
1871 size_t return_key_length;
1872 char *value;
1873 size_t value_length;
1874 uint32_t flags;
1875 unsigned int count;
1876 unsigned int x;
1877 char insert_data[VALUE_SIZE_BUG5];
1878
1879 for (x= 0; x < VALUE_SIZE_BUG5; x++)
1880 insert_data[x]= (signed char)rand();
1881
1882 memcached_flush(memc, 0);
1883 value= memcached_get(memc, keys[0], key_length[0],
1884 &value_length, &flags, &rc);
1885 assert(value == NULL);
1886 assert(rc == MEMCACHED_NOTFOUND);
1887 rc= memcached_mget(memc, keys, key_length, 4);
1888 assert(rc == MEMCACHED_SUCCESS);
1889
1890 count= 0;
1891 while ((value= memcached_fetch(memc, return_key, &return_key_length,
1892 &value_length, &flags, &rc)))
1893 count++;
1894 assert(count == 0);
1895 assert(rc == MEMCACHED_END);
1896
1897 for (x= 0; x < 4; x++)
1898 {
1899 rc= memcached_set(memc, keys[x], key_length[x],
1900 insert_data, VALUE_SIZE_BUG5,
1901 (time_t)0, (uint32_t)0);
1902 assert(rc == MEMCACHED_SUCCESS);
1903 }
1904
1905 for (x= 0; x < 2; x++)
1906 {
1907 value= memcached_get(memc, keys[0], key_length[0],
1908 &value_length, &flags, &rc);
1909 assert(value);
1910 free(value);
1911
1912 rc= memcached_mget(memc, keys, key_length, 4);
1913 assert(rc == MEMCACHED_SUCCESS);
1914 count= 3;
1915 /* We test for purge of partial complete fetches */
1916 for (count= 3; count; count--)
1917 {
1918 value= memcached_fetch(memc, return_key, &return_key_length,
1919 &value_length, &flags, &rc);
1920 assert(rc == MEMCACHED_SUCCESS);
1921 assert(!(memcmp(value, insert_data, value_length)));
1922 assert(value_length);
1923 free(value);
1924 }
1925 }
1926
1927 return 0;
1928 }
1929
1930 static test_return user_supplied_bug8(memcached_st *memc __attribute__((unused)))
1931 {
1932 memcached_return rc;
1933 memcached_st *mine;
1934 memcached_st *memc_clone;
1935
1936 memcached_server_st *servers;
1937 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";
1938
1939 servers= memcached_servers_parse(server_list);
1940 assert(servers);
1941
1942 mine= memcached_create(NULL);
1943 rc= memcached_server_push(mine, servers);
1944 assert(rc == MEMCACHED_SUCCESS);
1945 memcached_server_list_free(servers);
1946
1947 assert(mine);
1948 memc_clone= memcached_clone(NULL, mine);
1949
1950 memcached_quit(mine);
1951 memcached_quit(memc_clone);
1952
1953
1954 memcached_free(mine);
1955 memcached_free(memc_clone);
1956
1957 return 0;
1958 }
1959
1960 /* Test flag store/retrieve */
1961 static test_return user_supplied_bug7(memcached_st *memc)
1962 {
1963 memcached_return rc;
1964 const char *keys= "036790384900";
1965 size_t key_length= strlen(keys);
1966 char return_key[MEMCACHED_MAX_KEY];
1967 size_t return_key_length;
1968 char *value;
1969 size_t value_length;
1970 uint32_t flags;
1971 unsigned int x;
1972 char insert_data[VALUE_SIZE_BUG5];
1973
1974 for (x= 0; x < VALUE_SIZE_BUG5; x++)
1975 insert_data[x]= (signed char)rand();
1976
1977 memcached_flush(memc, 0);
1978
1979 flags= 245;
1980 rc= memcached_set(memc, keys, key_length,
1981 insert_data, VALUE_SIZE_BUG5,
1982 (time_t)0, flags);
1983 assert(rc == MEMCACHED_SUCCESS);
1984
1985 flags= 0;
1986 value= memcached_get(memc, keys, key_length,
1987 &value_length, &flags, &rc);
1988 assert(flags == 245);
1989 assert(value);
1990 free(value);
1991
1992 rc= memcached_mget(memc, &keys, &key_length, 1);
1993
1994 flags= 0;
1995 value= memcached_fetch(memc, return_key, &return_key_length,
1996 &value_length, &flags, &rc);
1997 assert(flags == 245);
1998 assert(value);
1999 free(value);
2000
2001
2002 return 0;
2003 }
2004
2005 static test_return user_supplied_bug9(memcached_st *memc)
2006 {
2007 memcached_return rc;
2008 const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2009 size_t key_length[3];
2010 unsigned int x;
2011 uint32_t flags;
2012 unsigned count= 0;
2013
2014 char return_key[MEMCACHED_MAX_KEY];
2015 size_t return_key_length;
2016 char *return_value;
2017 size_t return_value_length;
2018
2019
2020 key_length[0]= strlen("UDATA:edevil@sapo.pt");
2021 key_length[1]= strlen("fudge&*@#");
2022 key_length[2]= strlen("for^#@&$not");
2023
2024
2025 for (x= 0; x < 3; x++)
2026 {
2027 rc= memcached_set(memc, keys[x], key_length[x],
2028 keys[x], key_length[x],
2029 (time_t)50, (uint32_t)9);
2030 assert(rc == MEMCACHED_SUCCESS);
2031 }
2032
2033 rc= memcached_mget(memc, keys, key_length, 3);
2034 assert(rc == MEMCACHED_SUCCESS);
2035
2036 /* We need to empty the server before continueing test */
2037 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2038 &return_value_length, &flags, &rc)) != NULL)
2039 {
2040 assert(return_value);
2041 free(return_value);
2042 count++;
2043 }
2044 assert(count == 3);
2045
2046 return 0;
2047 }
2048
2049 /* We are testing with aggressive timeout to get failures */
2050 static test_return user_supplied_bug10(memcached_st *memc)
2051 {
2052 const char *key= "foo";
2053 char *value;
2054 size_t value_length= 512;
2055 unsigned int x;
2056 size_t key_len= 3;
2057 memcached_return rc;
2058 unsigned int set= 1;
2059 memcached_st *mclone= memcached_clone(NULL, memc);
2060 int32_t timeout;
2061
2062 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
2063 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
2064 timeout= 2;
2065 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
2066 (uint64_t)timeout);
2067
2068 value = (char*)malloc(value_length * sizeof(char));
2069
2070 for (x= 0; x < value_length; x++)
2071 value[x]= (char) (x % 127);
2072
2073 for (x= 1; x <= 100000; ++x)
2074 {
2075 rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
2076
2077 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE ||
2078 rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT);
2079
2080 if (rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_TIMEOUT)
2081 x--;
2082 }
2083
2084 free(value);
2085 memcached_free(mclone);
2086
2087 return 0;
2088 }
2089
2090 /*
2091 We are looking failures in the async protocol
2092 */
2093 static test_return user_supplied_bug11(memcached_st *memc)
2094 {
2095 const char *key= "foo";
2096 char *value;
2097 size_t value_length= 512;
2098 unsigned int x;
2099 size_t key_len= 3;
2100 memcached_return rc;
2101 unsigned int set= 1;
2102 int32_t timeout;
2103 memcached_st *mclone= memcached_clone(NULL, memc);
2104
2105 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
2106 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
2107 timeout= -1;
2108 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
2109 (size_t)timeout);
2110
2111 timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
2112
2113 assert(timeout == -1);
2114
2115 value = (char*)malloc(value_length * sizeof(char));
2116
2117 for (x= 0; x < value_length; x++)
2118 value[x]= (char) (x % 127);
2119
2120 for (x= 1; x <= 100000; ++x)
2121 {
2122 rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
2123 }
2124
2125 free(value);
2126 memcached_free(mclone);
2127
2128 return 0;
2129 }
2130
2131 /*
2132 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2133 */
2134 static test_return user_supplied_bug12(memcached_st *memc)
2135 {
2136 memcached_return rc;
2137 uint32_t flags;
2138 size_t value_length;
2139 char *value;
2140 uint64_t number_value;
2141
2142 value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
2143 &value_length, &flags, &rc);
2144 assert(value == NULL);
2145 assert(rc == MEMCACHED_NOTFOUND);
2146
2147 rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
2148 1, &number_value);
2149
2150 assert(value == NULL);
2151 /* The binary protocol will set the key if it doesn't exist */
2152 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
2153 assert(rc == MEMCACHED_SUCCESS);
2154 else
2155 assert(rc == MEMCACHED_NOTFOUND);
2156
2157 rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2158
2159 value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
2160 &value_length, &flags, &rc);
2161 assert(value);
2162 assert(rc == MEMCACHED_SUCCESS);
2163 free(value);
2164
2165 rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
2166 1, &number_value);
2167 assert(number_value == 2);
2168 assert(rc == MEMCACHED_SUCCESS);
2169
2170 return 0;
2171 }
2172
2173 /*
2174 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2175 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2176 */
2177 static test_return user_supplied_bug13(memcached_st *memc)
2178 {
2179 char key[] = "key34567890";
2180 char *overflow;
2181 memcached_return rc;
2182 size_t overflowSize;
2183
2184 char commandFirst[]= "set key34567890 0 0 ";
2185 char commandLast[] = " \r\n"; /* first line of command sent to server */
2186 size_t commandLength;
2187 size_t testSize;
2188
2189 commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
2190
2191 overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
2192
2193 for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
2194 {
2195 overflow= malloc(testSize);
2196 assert(overflow != NULL);
2197
2198 memset(overflow, 'x', testSize);
2199 rc= memcached_set(memc, key, strlen(key),
2200 overflow, testSize, 0, 0);
2201 assert(rc == MEMCACHED_SUCCESS);
2202 free(overflow);
2203 }
2204
2205 return 0;
2206 }
2207
2208
2209 /*
2210 Test values of many different sizes
2211 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2212 set key34567890 0 0 8169 \r\n
2213 is sent followed by buffer of size 8169, followed by 8169
2214 */
2215 static test_return user_supplied_bug14(memcached_st *memc)
2216 {
2217 size_t setter= 1;
2218 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
2219 memcached_return rc;
2220 const char *key= "foo";
2221 char *value;
2222 size_t value_length= 18000;
2223 char *string;
2224 size_t string_length;
2225 uint32_t flags;
2226 unsigned int x;
2227 size_t current_length;
2228
2229 value = (char*)malloc(value_length);
2230 assert(value);
2231
2232 for (x= 0; x < value_length; x++)
2233 value[x] = (char) (x % 127);
2234
2235 for (current_length= 0; current_length < value_length; current_length++)
2236 {
2237 rc= memcached_set(memc, key, strlen(key),
2238 value, current_length,
2239 (time_t)0, (uint32_t)0);
2240 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
2241
2242 string= memcached_get(memc, key, strlen(key),
2243 &string_length, &flags, &rc);
2244
2245 assert(rc == MEMCACHED_SUCCESS);
2246 assert(string_length == current_length);
2247 assert(!memcmp(string, value, string_length));
2248
2249 free(string);
2250 }
2251
2252 free(value);
2253
2254 return 0;
2255 }
2256
2257 /*
2258 Look for zero length value problems
2259 */
2260 static test_return user_supplied_bug15(memcached_st *memc)
2261 {
2262 uint32_t x;
2263 memcached_return rc;
2264 const char *key= "mykey";
2265 char *value;
2266 size_t length;
2267 uint32_t flags;
2268
2269 for (x= 0; x < 2; x++)
2270 {
2271 rc= memcached_set(memc, key, strlen(key),
2272 NULL, 0,
2273 (time_t)0, (uint32_t)0);
2274
2275 assert(rc == MEMCACHED_SUCCESS);
2276
2277 value= memcached_get(memc, key, strlen(key),
2278 &length, &flags, &rc);
2279
2280 assert(rc == MEMCACHED_SUCCESS);
2281 assert(value == NULL);
2282 assert(length == 0);
2283 assert(flags == 0);
2284
2285 value= memcached_get(memc, key, strlen(key),
2286 &length, &flags, &rc);
2287
2288 assert(rc == MEMCACHED_SUCCESS);
2289 assert(value == NULL);
2290 assert(length == 0);
2291 assert(flags == 0);
2292 }
2293
2294 return 0;
2295 }
2296
2297 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2298 static test_return user_supplied_bug16(memcached_st *memc)
2299 {
2300 memcached_return rc;
2301 const char *key= "mykey";
2302 char *value;
2303 size_t length;
2304 uint32_t flags;
2305
2306 rc= memcached_set(memc, key, strlen(key),
2307 NULL, 0,
2308 (time_t)0, UINT32_MAX);
2309
2310 assert(rc == MEMCACHED_SUCCESS);
2311
2312 value= memcached_get(memc, key, strlen(key),
2313 &length, &flags, &rc);
2314
2315 assert(rc == MEMCACHED_SUCCESS);
2316 assert(value == NULL);
2317 assert(length == 0);
2318 assert(flags == UINT32_MAX);
2319
2320 return 0;
2321 }
2322
2323 #ifndef __sun
2324 /* Check the validity of chinese key*/
2325 static test_return user_supplied_bug17(memcached_st *memc)
2326 {
2327 memcached_return rc;
2328 const char *key= "豆瓣";
2329 const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
2330 char *value2;
2331 size_t length;
2332 uint32_t flags;
2333
2334 rc= memcached_set(memc, key, strlen(key),
2335 value, strlen(value),
2336 (time_t)0, 0);
2337
2338 assert(rc == MEMCACHED_SUCCESS);
2339
2340 value2= memcached_get(memc, key, strlen(key),
2341 &length, &flags, &rc);
2342
2343 assert(length==strlen(value));
2344 assert(rc == MEMCACHED_SUCCESS);
2345 assert(memcmp(value, value2, length)==0);
2346 free(value2);
2347
2348 return 0;
2349 }
2350 #endif
2351
2352 /*
2353 From Andrei on IRC
2354 */
2355
2356 static test_return user_supplied_bug19(memcached_st *memc)
2357 {
2358 memcached_st *m;
2359 memcached_server_st *s;
2360 memcached_return res;
2361
2362 (void)memc;
2363
2364 m= memcached_create(NULL);
2365 memcached_server_add_with_weight(m, "localhost", 11311, 100);
2366 memcached_server_add_with_weight(m, "localhost", 11312, 100);
2367
2368 s= memcached_server_by_key(m, "a", 1, &res);
2369 memcached_server_free(s);
2370
2371 memcached_free(m);
2372
2373 return 0;
2374 }
2375
2376 /* CAS test from Andei */
2377 static test_return user_supplied_bug20(memcached_st *memc)
2378 {
2379 memcached_return status;
2380 memcached_result_st *result, result_obj;
2381 const char *key = "abc";
2382 size_t key_len = strlen("abc");
2383 const char *value = "foobar";
2384 size_t value_len = strlen(value);
2385
2386 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
2387
2388 status = memcached_set(memc, key, key_len, value, value_len, (time_t)0, (uint32_t)0);
2389 assert(status == MEMCACHED_SUCCESS);
2390
2391 status = memcached_mget(memc, &key, &key_len, 1);
2392 assert(status == MEMCACHED_SUCCESS);
2393
2394 result= memcached_result_create(memc, &result_obj);
2395 assert(result);
2396
2397 memcached_result_create(memc, &result_obj);
2398 result= memcached_fetch_result(memc, &result_obj, &status);
2399
2400 assert(result);
2401 assert(status == MEMCACHED_SUCCESS);
2402
2403 memcached_result_free(result);
2404
2405 return 0;
2406 }
2407
2408 #include "ketama_test_cases.h"
2409 static test_return user_supplied_bug18(memcached_st *trash)
2410 {
2411 memcached_return rc;
2412 uint64_t value;
2413 int x;
2414 memcached_server_st *server_pool;
2415 memcached_st *memc;
2416
2417 (void)trash;
2418
2419 memc= memcached_create(NULL);
2420 assert(memc);
2421
2422 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
2423 assert(rc == MEMCACHED_SUCCESS);
2424
2425 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
2426 assert(value == 1);
2427
2428 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
2429 assert(rc == MEMCACHED_SUCCESS);
2430
2431 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
2432 assert(value == MEMCACHED_HASH_MD5);
2433
2434 server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
2435 memcached_server_push(memc, server_pool);
2436
2437 /* verify that the server list was parsed okay. */
2438 assert(memc->number_of_hosts == 8);
2439 assert(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
2440 assert(server_pool[0].port == 11211);
2441 assert(server_pool[0].weight == 600);
2442 assert(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
2443 assert(server_pool[2].port == 11211);
2444 assert(server_pool[2].weight == 200);
2445 assert(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
2446 assert(server_pool[7].port == 11211);
2447 assert(server_pool[7].weight == 100);
2448
2449 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2450 * us test the boundary wraparound.
2451 */
2452 assert(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
2453
2454 /* verify the standard ketama set. */
2455 for (x= 0; x < 99; x++)
2456 {
2457 uint32_t server_idx = memcached_generate_hash(memc, test_cases[x].key, strlen(test_cases[x].key));
2458 char *hostname = memc->hosts[server_idx].hostname;
2459 assert(strcmp(hostname, test_cases[x].server) == 0);
2460 }
2461
2462 memcached_server_list_free(server_pool);
2463 memcached_free(memc);
2464
2465 return 0;
2466 }
2467
2468 static test_return auto_eject_hosts(memcached_st *trash)
2469 {
2470 (void) trash;
2471
2472 memcached_return rc;
2473 memcached_st *memc= memcached_create(NULL);
2474 assert(memc);
2475
2476 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
2477 assert(rc == MEMCACHED_SUCCESS);
2478
2479 uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
2480 assert(value == 1);
2481
2482 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
2483 assert(rc == MEMCACHED_SUCCESS);
2484
2485 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
2486 assert(value == MEMCACHED_HASH_MD5);
2487
2488 /* server should be removed when in delay */
2489 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS, 1);
2490 assert(rc == MEMCACHED_SUCCESS);
2491
2492 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS);
2493 assert(value == 1);
2494
2495 memcached_server_st *server_pool;
2496 server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
2497 memcached_server_push(memc, server_pool);
2498
2499 /* verify that the server list was parsed okay. */
2500 assert(memc->number_of_hosts == 8);
2501 assert(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
2502 assert(server_pool[0].port == 11211);
2503 assert(server_pool[0].weight == 600);
2504 assert(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
2505 assert(server_pool[2].port == 11211);
2506 assert(server_pool[2].weight == 200);
2507 assert(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
2508 assert(server_pool[7].port == 11211);
2509 assert(server_pool[7].weight == 100);
2510
2511 memc->hosts[2].next_retry = time(NULL) + 15;
2512 memc->next_distribution_rebuild= time(NULL) - 1;
2513
2514 for (int x= 0; x < 99; x++)
2515 {
2516 uint32_t server_idx = memcached_generate_hash(memc, test_cases[x].key, strlen(test_cases[x].key));
2517 assert(server_idx != 2);
2518 }
2519
2520 /* and re-added when it's back. */
2521 memc->hosts[2].next_retry = time(NULL) - 1;
2522 memc->next_distribution_rebuild= time(NULL) - 1;
2523 run_distribution(memc);
2524 for (int x= 0; x < 99; x++)
2525 {
2526 uint32_t server_idx = memcached_generate_hash(memc, test_cases[x].key, strlen(test_cases[x].key));
2527 char *hostname = memc->hosts[server_idx].hostname;
2528 assert(strcmp(hostname, test_cases[x].server) == 0);
2529 }
2530
2531 memcached_server_list_free(server_pool);
2532 memcached_free(memc);
2533
2534 return TEST_SUCCESS;
2535 }
2536
2537 static test_return result_static(memcached_st *memc)
2538 {
2539 memcached_result_st result;
2540 memcached_result_st *result_ptr;
2541
2542 result_ptr= memcached_result_create(memc, &result);
2543 assert(result.is_allocated == false);
2544 assert(result_ptr);
2545 memcached_result_free(&result);
2546
2547 return 0;
2548 }
2549
2550 static test_return result_alloc(memcached_st *memc)
2551 {
2552 memcached_result_st *result;
2553
2554 result= memcached_result_create(memc, NULL);
2555 assert(result);
2556 memcached_result_free(result);
2557
2558 return 0;
2559 }
2560
2561 static test_return string_static_null(memcached_st *memc)
2562 {
2563 memcached_string_st string;
2564 memcached_string_st *string_ptr;
2565
2566 string_ptr= memcached_string_create(memc, &string, 0);
2567 assert(string.is_allocated == false);
2568 assert(string_ptr);
2569 memcached_string_free(&string);
2570
2571 return 0;
2572 }
2573
2574 static test_return string_alloc_null(memcached_st *memc)
2575 {
2576 memcached_string_st *string;
2577
2578 string= memcached_string_create(memc, NULL, 0);
2579 assert(string);
2580 memcached_string_free(string);
2581
2582 return 0;
2583 }
2584
2585 static test_return string_alloc_with_size(memcached_st *memc)
2586 {
2587 memcached_string_st *string;
2588
2589 string= memcached_string_create(memc, NULL, 1024);
2590 assert(string);
2591 memcached_string_free(string);
2592
2593 return 0;
2594 }
2595
2596 static test_return string_alloc_with_size_toobig(memcached_st *memc)
2597 {
2598 memcached_string_st *string;
2599
2600 string= memcached_string_create(memc, NULL, SIZE_MAX);
2601 assert(string == NULL);
2602
2603 return 0;
2604 }
2605
2606 static test_return string_alloc_append(memcached_st *memc)
2607 {
2608 unsigned int x;
2609 char buffer[SMALL_STRING_LEN];
2610 memcached_string_st *string;
2611
2612 /* Ring the bell! */
2613 memset(buffer, 6, SMALL_STRING_LEN);
2614
2615 string= memcached_string_create(memc, NULL, 100);
2616 assert(string);
2617
2618 for (x= 0; x < 1024; x++)
2619 {
2620 memcached_return rc;
2621 rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
2622 assert(rc == MEMCACHED_SUCCESS);
2623 }
2624 memcached_string_free(string);
2625
2626 return 0;
2627 }
2628
2629 static test_return string_alloc_append_toobig(memcached_st *memc)
2630 {
2631 memcached_return rc;
2632 unsigned int x;
2633 char buffer[SMALL_STRING_LEN];
2634 memcached_string_st *string;
2635
2636 /* Ring the bell! */
2637 memset(buffer, 6, SMALL_STRING_LEN);
2638
2639 string= memcached_string_create(memc, NULL, 100);
2640 assert(string);
2641
2642 for (x= 0; x < 1024; x++)
2643 {
2644 rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
2645 assert(rc == MEMCACHED_SUCCESS);
2646 }
2647 rc= memcached_string_append(string, buffer, SIZE_MAX);
2648 assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
2649 memcached_string_free(string);
2650
2651 return 0;
2652 }
2653
2654 static test_return cleanup_pairs(memcached_st *memc __attribute__((unused)))
2655 {
2656 pairs_free(global_pairs);
2657
2658 return 0;
2659 }
2660
2661 static test_return generate_pairs(memcached_st *memc __attribute__((unused)))
2662 {
2663 unsigned long long x;
2664 global_pairs= pairs_generate(GLOBAL_COUNT, 400);
2665 global_count= GLOBAL_COUNT;
2666
2667 for (x= 0; x < global_count; x++)
2668 {
2669 global_keys[x]= global_pairs[x].key;
2670 global_keys_length[x]= global_pairs[x].key_length;
2671 }
2672
2673 return 0;
2674 }
2675
2676 static test_return generate_large_pairs(memcached_st *memc __attribute__((unused)))
2677 {
2678 unsigned long long x;
2679 global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
2680 global_count= GLOBAL2_COUNT;
2681
2682 for (x= 0; x < global_count; x++)
2683 {
2684 global_keys[x]= global_pairs[x].key;
2685 global_keys_length[x]= global_pairs[x].key_length;
2686 }
2687
2688 return 0;
2689 }
2690
2691 static test_return generate_data(memcached_st *memc)
2692 {
2693 execute_set(memc, global_pairs, global_count);
2694
2695 return 0;
2696 }
2697
2698 static test_return generate_data_with_stats(memcached_st *memc)
2699 {
2700 memcached_stat_st *stat_p;
2701 memcached_return rc;
2702 uint32_t host_index= 0;
2703 execute_set(memc, global_pairs, global_count);
2704
2705 //TODO: hosts used size stats
2706 stat_p= memcached_stat(memc, NULL, &rc);
2707 assert(stat_p);
2708
2709 for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++)
2710 {
2711 /* This test was changes so that "make test" would work properlly */
2712 #ifdef DEBUG
2713 printf("\nserver %u|%s|%u bytes: %llu\n", host_index, (memc->hosts)[host_index].hostname, (memc->hosts)[host_index].port, (unsigned long long)(stat_p + host_index)->bytes);
2714 #endif
2715 assert((unsigned long long)(stat_p + host_index)->bytes);
2716 }
2717
2718 memcached_stat_free(NULL, stat_p);
2719
2720 return 0;
2721 }
2722 static test_return generate_buffer_data(memcached_st *memc)
2723 {
2724 size_t latch= 0;
2725
2726 latch= 1;
2727 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
2728 generate_data(memc);
2729
2730 return 0;
2731 }
2732
2733 static test_return get_read_count(memcached_st *memc)
2734 {
2735 unsigned int x;
2736 memcached_return rc;
2737 memcached_st *memc_clone;
2738
2739 memc_clone= memcached_clone(NULL, memc);
2740 assert(memc_clone);
2741
2742 memcached_server_add_with_weight(memc_clone, "localhost", 6666, 0);
2743
2744 {
2745 char *return_value;
2746 size_t return_value_length;
2747 uint32_t flags;
2748 uint32_t count;
2749
2750 for (x= count= 0; x < global_count; x++)
2751 {
2752 return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x],
2753 &return_value_length, &flags, &rc);
2754 if (rc == MEMCACHED_SUCCESS)
2755 {
2756 count++;
2757 if (return_value)
2758 free(return_value);
2759 }
2760 }
2761 fprintf(stderr, "\t%u -> %u", global_count, count);
2762 }
2763
2764 memcached_free(memc_clone);
2765
2766 return 0;
2767 }
2768
2769 static test_return get_read(memcached_st *memc)
2770 {
2771 unsigned int x;
2772 memcached_return rc;
2773
2774 {
2775 char *return_value;
2776 size_t return_value_length;
2777 uint32_t flags;
2778
2779 for (x= 0; x < global_count; x++)
2780 {
2781 return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
2782 &return_value_length, &flags, &rc);
2783 /*
2784 assert(return_value);
2785 assert(rc == MEMCACHED_SUCCESS);
2786 */
2787 if (rc == MEMCACHED_SUCCESS && return_value)
2788 free(return_value);
2789 }
2790 }
2791
2792 return 0;
2793 }
2794
2795 static test_return mget_read(memcached_st *memc)
2796 {
2797 memcached_return rc;
2798
2799 rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2800 assert(rc == MEMCACHED_SUCCESS);
2801 /* Turn this into a help function */
2802 {
2803 char return_key[MEMCACHED_MAX_KEY];
2804 size_t return_key_length;
2805 char *return_value;
2806 size_t return_value_length;
2807 uint32_t flags;
2808
2809 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2810 &return_value_length, &flags, &rc)))
2811 {
2812 assert(return_value);
2813 assert(rc == MEMCACHED_SUCCESS);
2814 free(return_value);
2815 }
2816 }
2817
2818 return 0;
2819 }
2820
2821 static test_return mget_read_result(memcached_st *memc)
2822 {
2823 memcached_return rc;
2824
2825 rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2826 assert(rc == MEMCACHED_SUCCESS);
2827 /* Turn this into a help function */
2828 {
2829 memcached_result_st results_obj;
2830 memcached_result_st *results;
2831
2832 results= memcached_result_create(memc, &results_obj);
2833
2834 while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
2835 {
2836 assert(results);
2837 assert(rc == MEMCACHED_SUCCESS);
2838 }
2839
2840 memcached_result_free(&results_obj);
2841 }
2842
2843 return 0;
2844 }
2845
2846 static test_return mget_read_function(memcached_st *memc)
2847 {
2848 memcached_return rc;
2849 unsigned int counter;
2850 memcached_execute_function callbacks[1];
2851
2852 rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2853 assert(rc == MEMCACHED_SUCCESS);
2854
2855 callbacks[0]= &callback_counter;
2856 counter= 0;
2857 rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
2858
2859 return 0;
2860 }
2861
2862 static test_return delete_generate(memcached_st *memc)
2863 {
2864 unsigned int x;
2865
2866 for (x= 0; x < global_count; x++)
2867 {
2868 (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2869 }
2870
2871 return 0;
2872 }
2873
2874 static test_return delete_buffer_generate(memcached_st *memc)
2875 {
2876 size_t latch= 0;
2877 unsigned int x;
2878
2879 latch= 1;
2880 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
2881
2882 for (x= 0; x < global_count; x++)
2883 {
2884 (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2885 }
2886
2887 return 0;
2888 }
2889
2890 static test_return add_host_test1(memcached_st *memc)
2891 {
2892 unsigned int x;
2893 memcached_return rc;
2894 char servername[]= "0.example.com";
2895 memcached_server_st *servers;
2896
2897 servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
2898 assert(servers);
2899 assert(1 == memcached_server_list_count(servers));
2900
2901 for (x= 2; x < 20; x++)
2902 {
2903 char buffer[SMALL_STRING_LEN];
2904
2905 snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
2906 servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
2907 &rc);
2908 assert(rc == MEMCACHED_SUCCESS);
2909 assert(x == memcached_server_list_count(servers));
2910 }
2911
2912 rc= memcached_server_push(memc, servers);
2913 assert(rc == MEMCACHED_SUCCESS);
2914 rc= memcached_server_push(memc, servers);
2915 assert(rc == MEMCACHED_SUCCESS);
2916
2917 memcached_server_list_free(servers);
2918
2919 return 0;
2920 }
2921
2922 static memcached_return pre_nonblock(memcached_st *memc)
2923 {
2924 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
2925
2926 return MEMCACHED_SUCCESS;
2927 }
2928
2929 static memcached_return pre_nonblock_binary(memcached_st *memc)
2930 {
2931 memcached_return rc= MEMCACHED_FAILURE;
2932 memcached_st *memc_clone;
2933
2934 memc_clone= memcached_clone(NULL, memc);
2935 assert(memc_clone);
2936 // The memcached_version needs to be done on a clone, because the server
2937 // will not toggle protocol on an connection.
2938 memcached_version(memc_clone);
2939
2940 if (memc_clone->hosts[0].major_version >= 1 && memc_clone->hosts[0].minor_version > 2)
2941 {
2942 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
2943 rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
2944 assert(rc == MEMCACHED_SUCCESS);
2945 assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
2946 }
2947
2948 memcached_free(memc_clone);
2949 return rc;
2950 }
2951
2952 static memcached_return pre_murmur(memcached_st *memc)
2953 {
2954 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
2955
2956 return MEMCACHED_SUCCESS;
2957 }
2958
2959 static memcached_return pre_jenkins(memcached_st *memc)
2960 {
2961 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_JENKINS);
2962
2963 return MEMCACHED_SUCCESS;
2964 }
2965
2966
2967 static memcached_return pre_md5(memcached_st *memc)
2968 {
2969 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5);
2970
2971 return MEMCACHED_SUCCESS;
2972 }
2973
2974 static memcached_return pre_crc(memcached_st *memc)
2975 {
2976 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_CRC);
2977
2978 return MEMCACHED_SUCCESS;
2979 }
2980
2981 static memcached_return pre_hsieh(memcached_st *memc)
2982 {
2983 #ifdef HAVE_HSIEH_HASH
2984 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH);
2985 return MEMCACHED_SUCCESS;
2986 #else
2987 (void) memc;
2988 return MEMCACHED_FAILURE;
2989 #endif
2990 }
2991
2992 static memcached_return pre_hash_fnv1_64(memcached_st *memc)
2993 {
2994 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_64);
2995
2996 return MEMCACHED_SUCCESS;
2997 }
2998
2999 static memcached_return pre_hash_fnv1a_64(memcached_st *memc)
3000 {
3001 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64);
3002
3003 return MEMCACHED_SUCCESS;
3004 }
3005
3006 static memcached_return pre_hash_fnv1_32(memcached_st *memc)
3007 {
3008 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_32);
3009
3010 return MEMCACHED_SUCCESS;
3011 }
3012
3013 static memcached_return pre_hash_fnv1a_32(memcached_st *memc)
3014 {
3015 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_32);
3016
3017 return MEMCACHED_SUCCESS;
3018 }
3019
3020 static memcached_return pre_behavior_ketama(memcached_st *memc)
3021 {
3022 memcached_return rc;
3023 uint64_t value;
3024
3025 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1);
3026 assert(rc == MEMCACHED_SUCCESS);
3027
3028 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);
3029 assert(value == 1);
3030
3031 return MEMCACHED_SUCCESS;
3032 }
3033
3034 static memcached_return pre_behavior_ketama_weighted(memcached_st *memc)
3035 {
3036 memcached_return rc;
3037 uint64_t value;
3038
3039 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
3040 assert(rc == MEMCACHED_SUCCESS);
3041
3042 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
3043 assert(value == 1);
3044
3045 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
3046 assert(rc == MEMCACHED_SUCCESS);
3047
3048 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
3049 assert(value == MEMCACHED_HASH_MD5);
3050 return MEMCACHED_SUCCESS;
3051 }
3052
3053 static memcached_return pre_binary(memcached_st *memc)
3054 {
3055 memcached_return rc= MEMCACHED_FAILURE;
3056 memcached_st *memc_clone;
3057
3058 memc_clone= memcached_clone(NULL, memc);
3059 assert(memc_clone);
3060 // The memcached_version needs to be done on a clone, because the server
3061 // will not toggle protocol on an connection.
3062 memcached_version(memc_clone);
3063
3064 if (memc_clone->hosts[0].major_version >= 1 && memc_clone->hosts[0].minor_version > 2)
3065 {
3066 rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3067 assert(rc == MEMCACHED_SUCCESS);
3068 assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
3069 }
3070
3071 memcached_free(memc_clone);
3072 return rc;
3073 }
3074
3075 static memcached_return pre_replication(memcached_st *memc)
3076 {
3077 memcached_return rc= MEMCACHED_FAILURE;
3078 if (pre_binary(memc) == MEMCACHED_SUCCESS)
3079 {
3080 /*
3081 * Make sure that we store the item on all servers
3082 * (master + replicas == number of servers)
3083 */
3084 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS,
3085 memc->number_of_hosts - 1);
3086 assert(rc == MEMCACHED_SUCCESS);
3087 assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memc->number_of_hosts - 1);
3088 }
3089
3090 return rc;
3091 }
3092
3093 static memcached_return pre_replication_noblock(memcached_st *memc)
3094 {
3095 memcached_return rc= MEMCACHED_FAILURE;
3096 if (pre_replication(memc) == MEMCACHED_SUCCESS &&
3097 pre_nonblock(memc) == MEMCACHED_SUCCESS)
3098 rc= MEMCACHED_SUCCESS;
3099
3100 return rc;
3101 }
3102
3103 static void my_free(memcached_st *ptr __attribute__((unused)), void *mem)
3104 {
3105 free(mem);
3106 }
3107
3108 static void *my_malloc(memcached_st *ptr __attribute__((unused)), const size_t size)
3109 {
3110 void *ret= malloc(size);
3111 if (ret != NULL)
3112 memset(ret, 0xff, size);
3113
3114 return ret;
3115 }
3116
3117 static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, const size_t size)
3118 {
3119 return realloc(mem, size);
3120 }
3121
3122 static void *my_calloc(memcached_st *ptr __attribute__((unused)), size_t nelem, const size_t size)
3123 {
3124 return calloc(nelem, size);
3125 }
3126
3127 static memcached_return set_prefix(memcached_st *memc)
3128 {
3129 memcached_return rc;
3130 const char *key= "mine";
3131 char *value;
3132
3133 /* Make sure be default none exists */
3134 value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3135 assert(rc == MEMCACHED_FAILURE);
3136
3137 /* Test a clean set */
3138 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3139 assert(rc == MEMCACHED_SUCCESS);
3140
3141 value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3142 assert(memcmp(value, key, 4) == 0);
3143 assert(rc == MEMCACHED_SUCCESS);
3144
3145 /* Test that we can turn it off */
3146 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3147 assert(rc == MEMCACHED_SUCCESS);
3148
3149 value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3150 assert(rc == MEMCACHED_FAILURE);
3151
3152 /* Now setup for main test */
3153 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3154 assert(rc == MEMCACHED_SUCCESS);
3155
3156 value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3157 assert(rc == MEMCACHED_SUCCESS);
3158 assert(memcmp(value, key, 4) == 0);
3159
3160 /* Set to Zero, and then Set to something too large */
3161 {
3162 char long_key[255];
3163 memset(long_key, 0, 255);
3164
3165 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3166 assert(rc == MEMCACHED_SUCCESS);
3167
3168 value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3169 assert(rc == MEMCACHED_FAILURE);
3170 assert(value == NULL);
3171
3172 /* Test a long key for failure */
3173 /* TODO, extend test to determine based on setting, what result should be */
3174 strcpy(long_key, "Thisismorethentheallottednumberofcharacters");
3175 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3176 //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3177 assert(rc == MEMCACHED_SUCCESS);
3178
3179 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3180 strcpy(long_key, "This is more then the allotted number of characters");
3181 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3182 assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3183
3184 /* Test for a bad prefix, but with a short key */
3185 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
3186 assert(rc == MEMCACHED_SUCCESS);
3187
3188 strcpy(long_key, "dog cat");
3189 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3190 assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3191 }
3192
3193 return MEMCACHED_SUCCESS;
3194 }
3195
3196 #ifdef MEMCACHED_ENABLE_DEPRECATED
3197 static memcached_return deprecated_set_memory_alloc(memcached_st *memc)
3198 {
3199 void *test_ptr= NULL;
3200 void *cb_ptr= NULL;
3201 {
3202 memcached_malloc_function malloc_cb=
3203 (memcached_malloc_function)my_malloc;
3204 cb_ptr= *(void **)&malloc_cb;
3205 memcached_return rc;
3206
3207 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, cb_ptr);
3208 assert(rc == MEMCACHED_SUCCESS);
3209 test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
3210 assert(rc == MEMCACHED_SUCCESS);
3211 assert(test_ptr == cb_ptr);
3212 }
3213
3214 {
3215 memcached_realloc_function realloc_cb=
3216 (memcached_realloc_function)my_realloc;
3217 cb_ptr= *(void **)&realloc_cb;
3218 memcached_return rc;
3219
3220 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, cb_ptr);
3221 assert(rc == MEMCACHED_SUCCESS);
3222 test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
3223 assert(rc == MEMCACHED_SUCCESS);
3224 assert(test_ptr == cb_ptr);
3225 }
3226
3227 {
3228 memcached_free_function free_cb=
3229 (memcached_free_function)my_free;
3230 cb_ptr= *(void **)&free_cb;
3231 memcached_return rc;
3232
3233 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, cb_ptr);
3234 assert(rc == MEMCACHED_SUCCESS);
3235 test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
3236 assert(rc == MEMCACHED_SUCCESS);
3237 assert(test_ptr == cb_ptr);
3238 }
3239 return MEMCACHED_SUCCESS;
3240 }
3241 #endif
3242
3243 static memcached_return set_memory_alloc(memcached_st *memc)
3244 {
3245 memcached_return rc;
3246 rc= memcached_set_memory_allocators(memc, NULL, my_free,
3247 my_realloc, my_calloc);
3248 assert(rc == MEMCACHED_FAILURE);
3249
3250 rc= memcached_set_memory_allocators(memc, my_malloc, my_free,
3251 my_realloc, my_calloc);
3252
3253 memcached_malloc_function mem_malloc;
3254 memcached_free_function mem_free;
3255 memcached_realloc_function mem_realloc;
3256 memcached_calloc_function mem_calloc;
3257 memcached_get_memory_allocators(memc, &mem_malloc, &mem_free,
3258 &mem_realloc, &mem_calloc);
3259
3260 assert(mem_malloc == my_malloc);
3261 assert(mem_realloc == my_realloc);
3262 assert(mem_calloc == my_calloc);
3263 assert(mem_free == my_free);
3264
3265 return MEMCACHED_SUCCESS;
3266 }
3267
3268 static memcached_return enable_consistent(memcached_st *memc)
3269 {
3270 memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;
3271 memcached_hash hash;
3272 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
3273 if (pre_hsieh(memc) != MEMCACHED_SUCCESS)
3274 return MEMCACHED_FAILURE;
3275
3276 value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
3277 assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
3278
3279 hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
3280 assert(hash == MEMCACHED_HASH_HSIEH);
3281
3282
3283 return MEMCACHED_SUCCESS;
3284 }
3285
3286 static memcached_return enable_cas(memcached_st *memc)
3287 {
3288 unsigned int set= 1;
3289
3290 memcached_version(memc);
3291
3292 if ((memc->hosts[0].major_version >= 1 && (memc->hosts[0].minor_version == 2 && memc->hosts[0].micro_version >= 4))
3293 || memc->hosts[0].minor_version > 2)
3294 {
3295 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
3296
3297 return MEMCACHED_SUCCESS;
3298 }
3299
3300 return MEMCACHED_FAILURE;
3301 }
3302
3303 static memcached_return check_for_1_2_3(memcached_st *memc)
3304 {
3305 memcached_version(memc);
3306
3307 if ((memc->hosts[0].major_version >= 1 && (memc->hosts[0].minor_version == 2 && memc->hosts[0].micro_version >= 4))
3308 || memc->hosts[0].minor_version > 2)
3309 return MEMCACHED_SUCCESS;
3310
3311 return MEMCACHED_FAILURE;
3312 }
3313
3314 static memcached_return pre_unix_socket(memcached_st *memc)
3315 {
3316 memcached_return rc;
3317 struct stat buf;
3318
3319 memcached_server_list_free(memc->hosts);
3320 memc->hosts= NULL;
3321 memc->number_of_hosts= 0;
3322
3323 if (stat("/tmp/memcached.socket", &buf))
3324 return MEMCACHED_FAILURE;
3325
3326 rc= memcached_server_add_unix_socket_with_weight(memc, "/tmp/memcached.socket", 0);
3327
3328 return rc;
3329 }
3330
3331 static memcached_return pre_nodelay(memcached_st *memc)
3332 {
3333 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
3334 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
3335
3336 return MEMCACHED_SUCCESS;
3337 }
3338
3339 static memcached_return pre_settimer(memcached_st *memc)
3340 {
3341 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
3342 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
3343
3344 return MEMCACHED_SUCCESS;
3345 }
3346
3347 static memcached_return poll_timeout(memcached_st *memc)
3348 {
3349 size_t timeout;
3350
3351 timeout= 100;
3352
3353 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
3354
3355 timeout= (size_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
3356
3357 assert(timeout == 100);
3358
3359 return MEMCACHED_SUCCESS;
3360 }
3361
3362 static test_return noreply_test(memcached_st *memc)
3363 {
3364 memcached_return ret;
3365 ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
3366 assert(ret == MEMCACHED_SUCCESS);
3367 ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
3368 assert(ret == MEMCACHED_SUCCESS);
3369 ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
3370 assert(ret == MEMCACHED_SUCCESS);
3371 assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY) == 1);
3372 assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS) == 1);
3373 assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS) == 1);
3374
3375 for (int count=0; count < 5; ++count)
3376 {
3377 for (int x=0; x < 100; ++x)
3378 {
3379 char key[10];
3380 size_t len= (size_t)sprintf(key, "%d", x);
3381 switch (count)
3382 {
3383 case 0:
3384 ret=memcached_add(memc, key, len, key, len, 0, 0);
3385 break;
3386 case 1:
3387 ret=memcached_replace(memc, key, len, key, len, 0, 0);
3388 break;
3389 case 2:
3390 ret=memcached_set(memc, key, len, key, len, 0, 0);
3391 break;
3392 case 3:
3393 ret=memcached_append(memc, key, len, key, len, 0, 0);
3394 break;
3395 case 4:
3396 ret=memcached_prepend(memc, key, len, key, len, 0, 0);
3397 break;
3398 default:
3399 assert(count);
3400 break;
3401 }
3402 assert(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED);
3403 }
3404
3405 /*
3406 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3407 ** API and is _ONLY_ done this way to verify that the library works the
3408 ** way it is supposed to do!!!!
3409 */
3410 int no_msg=0;
3411 for (uint32_t x=0; x < memc->number_of_hosts; ++x)
3412 no_msg+=(int)(memc->hosts[x].cursor_active);
3413
3414 assert(no_msg == 0);
3415 assert(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
3416
3417 /*
3418 ** Now validate that all items was set properly!
3419 */
3420 for (int x=0; x < 100; ++x)
3421 {
3422 char key[10];
3423 size_t len= (size_t)sprintf(key, "%d", x);
3424 size_t length;
3425 uint32_t flags;
3426 char* value=memcached_get(memc, key, strlen(key),
3427 &length, &flags, &ret);
3428 assert(ret == MEMCACHED_SUCCESS && value != NULL);
3429 switch (count)
3430 {
3431 case 0: /* FALLTHROUGH */
3432 case 1: /* FALLTHROUGH */
3433 case 2:
3434 assert(strncmp(value, key, len) == 0);
3435 assert(len == length);
3436 break;
3437 case 3:
3438 assert(length == len * 2);
3439 break;
3440 case 4:
3441 assert(length == len * 3);
3442 break;
3443 default:
3444 assert(count);
3445 break;
3446 }
3447 free(value);
3448 }
3449 }
3450
3451 /* Try setting an illegal cas value (should not return an error to
3452 * the caller (because we don't expect a return message from the server)
3453 */
3454 const char* keys[]= {"0"};
3455 size_t lengths[]= {1};
3456 size_t length;
3457 uint32_t flags;
3458 memcached_result_st results_obj;
3459 memcached_result_st *results;
3460 ret= memcached_mget(memc, keys, lengths, 1);
3461 assert(ret == MEMCACHED_SUCCESS);
3462
3463 results= memcached_result_create(memc, &results_obj);
3464 assert(results);
3465 results= memcached_fetch_result(memc, &results_obj, &ret);
3466 assert(results);
3467 assert(ret == MEMCACHED_SUCCESS);
3468 uint64_t cas= memcached_result_cas(results);
3469 memcached_result_free(&results_obj);
3470
3471 ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
3472 assert(ret == MEMCACHED_SUCCESS);
3473
3474 /*
3475 * The item will have a new cas value, so try to set it again with the old
3476 * value. This should fail!
3477 */
3478 ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
3479 assert(ret == MEMCACHED_SUCCESS);
3480 assert(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
3481 char* value=memcached_get(memc, keys[0], lengths[0], &length, &flags, &ret);
3482 assert(ret == MEMCACHED_SUCCESS && value != NULL);
3483 free(value);
3484
3485 return TEST_SUCCESS;
3486 }
3487
3488 static test_return analyzer_test(memcached_st *memc)
3489 {
3490 memcached_return rc;
3491 memcached_stat_st *memc_stat;
3492 memcached_analysis_st *report;
3493
3494 memc_stat= memcached_stat(memc, NULL, &rc);
3495 assert(rc == MEMCACHED_SUCCESS);
3496 assert(memc_stat);
3497
3498 report= memcached_analyze(memc, memc_stat, &rc);
3499 assert(rc == MEMCACHED_SUCCESS);
3500 assert(report);
3501
3502 free(report);
3503 memcached_stat_free(NULL, memc_stat);
3504
3505 return TEST_SUCCESS;
3506 }
3507
3508 /* Count the objects */
3509 static memcached_return callback_dump_counter(memcached_st *ptr __attribute__((unused)),
3510 const char *key __attribute__((unused)),
3511 size_t key_length __attribute__((unused)),
3512 void *context)
3513 {
3514 uint32_t *counter= (uint32_t *)context;
3515
3516 *counter= *counter + 1;
3517
3518 return MEMCACHED_SUCCESS;
3519 }
3520
3521 static test_return dump_test(memcached_st *memc)
3522 {
3523 memcached_return rc;
3524 uint32_t counter= 0;
3525 memcached_dump_func callbacks[1];
3526 test_return main_rc;
3527
3528 callbacks[0]= &callback_dump_counter;
3529
3530 /* No support for Binary protocol yet */
3531 if (memc->flags & MEM_BINARY_PROTOCOL)
3532 return TEST_SUCCESS;
3533
3534 main_rc= set_test3(memc);
3535
3536 assert (main_rc == TEST_SUCCESS);
3537
3538 rc= memcached_dump(memc, callbacks, (void *)&counter, 1);
3539 assert(rc == MEMCACHED_SUCCESS);
3540
3541 /* We may have more then 32 if our previous flush has not completed */
3542 assert(counter >= 32);
3543
3544 return TEST_SUCCESS;
3545 }
3546
3547 #ifdef HAVE_LIBMEMCACHEDUTIL
3548 static void* connection_release(void *arg) {
3549 struct {
3550 memcached_pool_st* pool;
3551 memcached_st* mmc;
3552 } *resource= arg;
3553
3554 usleep(250);
3555 assert(memcached_pool_push(resource->pool, resource->mmc) == MEMCACHED_SUCCESS);
3556 return arg;
3557 }
3558
3559 static test_return connection_pool_test(memcached_st *memc)
3560 {
3561 memcached_pool_st* pool= memcached_pool_create(memc, 5, 10);
3562 assert(pool != NULL);
3563 memcached_st* mmc[10];
3564 memcached_return rc;
3565
3566 for (int x= 0; x < 10; ++x) {
3567 mmc[x]= memcached_pool_pop(pool, false, &rc);
3568 assert(mmc[x] != NULL);
3569 assert(rc == MEMCACHED_SUCCESS);
3570 }
3571
3572 assert(memcached_pool_pop(pool, false, &rc) == NULL);
3573 assert(rc == MEMCACHED_SUCCESS);
3574
3575 pthread_t tid;
3576 struct {
3577 memcached_pool_st* pool;
3578 memcached_st* mmc;
3579 } item= { .pool = pool, .mmc = mmc[9] };
3580 pthread_create(&tid, NULL, connection_release, &item);
3581 mmc[9]= memcached_pool_pop(pool, true, &rc);
3582 assert(rc == MEMCACHED_SUCCESS);
3583 pthread_join(tid, NULL);
3584 assert(mmc[9] == item.mmc);
3585 const char *key= "key";
3586 size_t keylen= strlen(key);
3587
3588 // verify that I can do ops with all connections
3589 rc= memcached_set(mmc[0], key, keylen, "0", 1, 0, 0);
3590 assert(rc == MEMCACHED_SUCCESS);
3591
3592 for (unsigned int x= 0; x < 10; ++x) {
3593 uint64_t number_value;
3594 rc= memcached_increment(mmc[x], key, keylen, 1, &number_value);
3595 assert(rc == MEMCACHED_SUCCESS);
3596 assert(number_value == (x+1));
3597 }
3598
3599 // Release them..
3600 for (int x= 0; x < 10; ++x)
3601 assert(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS);
3602
3603 assert(memcached_pool_destroy(pool) == memc);
3604 return TEST_SUCCESS;
3605 }
3606 #endif
3607
3608 static test_return replication_set_test(memcached_st *memc)
3609 {
3610 memcached_return rc;
3611 memcached_st *memc_clone= memcached_clone(NULL, memc);
3612 memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
3613
3614 rc= memcached_set(memc, "bubba", 5, "0", 1, 0, 0);
3615 assert(rc == MEMCACHED_SUCCESS);
3616
3617 /*
3618 ** We are using the quiet commands to store the replicas, so we need
3619 ** to ensure that all of them are processed before we can continue.
3620 ** In the test we go directly from storing the object to trying to
3621 ** receive the object from all of the different servers, so we
3622 ** could end up in a race condition (the memcached server hasn't yet
3623 ** processed the quiet command from the replication set when it process
3624 ** the request from the other client (created by the clone)). As a
3625 ** workaround for that we call memcached_quit to send the quit command
3626 ** to the server and wait for the response ;-) If you use the test code
3627 ** as an example for your own code, please note that you shouldn't need
3628 ** to do this ;-)
3629 */
3630 memcached_quit(memc);
3631
3632 /*
3633 ** "bubba" should now be stored on all of our servers. We don't have an
3634 ** easy to use API to address each individual server, so I'll just iterate
3635 ** through a bunch of "master keys" and I should most likely hit all of the
3636 ** servers...
3637 */
3638 for (int x= 'a'; x <= 'z'; ++x)
3639 {
3640 char key[2]= { [0]= (char)x };
3641 size_t len;
3642 uint32_t flags;
3643 char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
3644 &len, &flags, &rc);
3645 assert(rc == MEMCACHED_SUCCESS);
3646 assert(val != NULL);
3647 free(val);
3648 }
3649
3650 memcached_free(memc_clone);
3651
3652 return TEST_SUCCESS;
3653 }
3654
3655 static test_return replication_get_test(memcached_st *memc)
3656 {
3657 memcached_return rc;
3658
3659 /*
3660 * Don't do the following in your code. I am abusing the internal details
3661 * within the library, and this is not a supported interface.
3662 * This is to verify correct behavior in the library
3663 */
3664 for (uint32_t host= 0; host < memc->number_of_hosts; ++host)
3665 {
3666 memcached_st *memc_clone= memcached_clone(NULL, memc);
3667 memc_clone->hosts[host].port= 0;
3668
3669 for (int x= 'a'; x <= 'z'; ++x)
3670 {
3671 char key[2]= { [0]= (char)x };
3672 size_t len;
3673 uint32_t flags;
3674 char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
3675 &len, &flags, &rc);
3676 assert(rc == MEMCACHED_SUCCESS);
3677 assert(val != NULL);
3678 free(val);
3679 }
3680
3681 memcached_free(memc_clone);
3682 }
3683
3684 return TEST_SUCCESS;
3685 }
3686
3687 static test_return replication_mget_test(memcached_st *memc)
3688 {
3689 memcached_return rc;
3690 memcached_st *memc_clone= memcached_clone(NULL, memc);
3691 memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
3692
3693 const char *keys[]= { "bubba", "key1", "key2", "key3" };
3694 size_t len[]= { 5, 4, 4, 4 };
3695
3696 for (int x=0; x< 4; ++x)
3697 {
3698 rc= memcached_set(memc, keys[x], len[x], "0", 1, 0, 0);
3699 assert(rc == MEMCACHED_SUCCESS);
3700 }
3701
3702 /*
3703 ** We are using the quiet commands to store the replicas, so we need
3704 ** to ensure that all of them are processed before we can continue.
3705 ** In the test we go directly from storing the object to trying to
3706 ** receive the object from all of the different servers, so we
3707 ** could end up in a race condition (the memcached server hasn't yet
3708 ** processed the quiet command from the replication set when it process
3709 ** the request from the other client (created by the clone)). As a
3710 ** workaround for that we call memcached_quit to send the quit command
3711 ** to the server and wait for the response ;-) If you use the test code
3712 ** as an example for your own code, please note that you shouldn't need
3713 ** to do this ;-)
3714 */
3715 memcached_quit(memc);
3716
3717 /*
3718 * Don't do the following in your code. I am abusing the internal details
3719 * within the library, and this is not a supported interface.
3720 * This is to verify correct behavior in the library
3721 */
3722 memcached_result_st result_obj;
3723 for (uint32_t host= 0; host < memc_clone->number_of_hosts; host++)
3724 {
3725 memcached_st *new_clone= memcached_clone(NULL, memc);
3726 new_clone->hosts[host].port= 0;
3727
3728 for (int x= 'a'; x <= 'z'; ++x)
3729 {
3730 const char key[2]= { [0]= (const char)x };
3731
3732 rc= memcached_mget_by_key(new_clone, key, 1, keys, len, 4);
3733 assert(rc == MEMCACHED_SUCCESS);
3734
3735 memcached_result_st *results= memcached_result_create(new_clone, &result_obj);
3736 assert(results);
3737
3738 int hits= 0;
3739 while ((results= memcached_fetch_result(new_clone, &result_obj, &rc)) != NULL)
3740 {
3741 hits++;
3742 }
3743 assert(hits == 4);
3744 memcached_result_free(&result_obj);
3745 }
3746
3747 memcached_free(new_clone);
3748 }
3749
3750 memcached_free(memc_clone);
3751
3752 return TEST_SUCCESS;
3753 }
3754
3755 static test_return replication_delete_test(memcached_st *memc)
3756 {
3757 memcached_return rc;
3758 memcached_st *memc_clone= memcached_clone(NULL, memc);
3759 /* Delete the items from all of the servers except 1 */
3760 uint64_t repl= memcached_behavior_get(memc,
3761 MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
3762 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, --repl);
3763
3764 const char *keys[]= { "bubba", "key1", "key2", "key3" };
3765 size_t len[]= { 5, 4, 4, 4 };
3766
3767 for (int x=0; x< 4; ++x)
3768 {
3769 rc= memcached_delete_by_key(memc, keys[0], len[0], keys[x], len[x], 0);
3770 assert(rc == MEMCACHED_SUCCESS);
3771 }
3772
3773 /*
3774 * Don't do the following in your code. I am abusing the internal details
3775 * within the library, and this is not a supported interface.
3776 * This is to verify correct behavior in the library
3777 */
3778 uint32_t hash= memcached_generate_hash(memc, keys[0], len[0]);
3779 for (uint32_t x= 0; x < (repl + 1); ++x)
3780 {
3781 memc_clone->hosts[hash].port= 0;
3782 if (++hash == memc_clone->number_of_hosts)
3783 hash= 0;
3784 }
3785
3786 memcached_result_st result_obj;
3787 for (uint32_t host= 0; host < memc_clone->number_of_hosts; ++host)
3788 {
3789 for (int x= 'a'; x <= 'z'; ++x)
3790 {
3791 const char key[2]= { [0]= (const char)x };
3792
3793 rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 4);
3794 assert(rc == MEMCACHED_SUCCESS);
3795
3796 memcached_result_st *results= memcached_result_create(memc_clone, &result_obj);
3797 assert(results);
3798
3799 int hits= 0;
3800 while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL)
3801 {
3802 ++hits;
3803 }
3804 assert(hits == 4);
3805 memcached_result_free(&result_obj);
3806 }
3807 }
3808 memcached_free(memc_clone);
3809
3810 return TEST_SUCCESS;
3811 }
3812
3813 static void increment_request_id(uint16_t *id)
3814 {
3815 (*id)++;
3816 if ((*id & UDP_REQUEST_ID_THREAD_MASK) != 0)
3817 *id= 0;
3818 }
3819
3820 static uint16_t *get_udp_request_ids(memcached_st *memc)
3821 {
3822 uint16_t *ids= malloc(sizeof(uint16_t) * memc->number_of_hosts);
3823 assert(ids != NULL);
3824 unsigned int x;
3825
3826 for (x= 0; x < memc->number_of_hosts; x++)
3827 ids[x]= get_udp_datagram_request_id((struct udp_datagram_header_st *) memc->hosts[x].write_buffer);
3828
3829 return ids;
3830 }
3831
3832 static test_return post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ids)
3833 {
3834 unsigned int x;
3835 memcached_server_st *cur_server = memc->hosts;
3836 uint16_t *cur_req_ids = get_udp_request_ids(memc);
3837
3838 for (x= 0; x < memc->number_of_hosts; x++)
3839 {
3840 assert(cur_server[x].cursor_active == 0);
3841 assert(cur_req_ids[x] == expected_req_ids[x]);
3842 }
3843 free(expected_req_ids);
3844 free(cur_req_ids);
3845
3846 return TEST_SUCCESS;
3847 }
3848
3849 /*
3850 ** There is a little bit of a hack here, instead of removing
3851 ** the servers, I just set num host to 0 and them add then new udp servers
3852 **/
3853 static memcached_return init_udp(memcached_st *memc)
3854 {
3855 memcached_version(memc);
3856 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
3857 if (memc->hosts[0].major_version != 1 || memc->hosts[0].minor_version != 2
3858 || memc->hosts[0].micro_version < 6)
3859 return MEMCACHED_FAILURE;
3860
3861 uint32_t num_hosts= memc->number_of_hosts;
3862 unsigned int x= 0;
3863 memcached_server_st servers[num_hosts];
3864 memcpy(servers, memc->hosts, sizeof(memcached_server_st) * num_hosts);
3865 for (x= 0; x < num_hosts; x++)
3866 memcached_server_free(&memc->hosts[x]);
3867
3868 memc->number_of_hosts= 0;
3869 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1);
3870 for (x= 0; x < num_hosts; x++)
3871 {
3872 assert(memcached_server_add_udp(memc, servers[x].hostname, servers[x].port) == MEMCACHED_SUCCESS);
3873 assert(memc->hosts[x].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
3874 }
3875
3876 return MEMCACHED_SUCCESS;
3877 }
3878
3879 static memcached_return binary_init_udp(memcached_st *memc)
3880 {
3881 pre_binary(memc);
3882 return init_udp(memc);
3883 }
3884
3885 /* Make sure that I cant add a tcp server to a udp client */
3886 static test_return add_tcp_server_udp_client_test(memcached_st *memc)
3887 {
3888 memcached_server_st server;
3889 memcached_server_clone(&server, &memc->hosts[0]);
3890 assert(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
3891 assert(memcached_server_add(memc, server.hostname, server.port) == MEMCACHED_INVALID_HOST_PROTOCOL);
3892 return TEST_SUCCESS;
3893 }
3894
3895 /* Make sure that I cant add a udp server to a tcp client */
3896 static test_return add_udp_server_tcp_client_test(memcached_st *memc)
3897 {
3898 memcached_server_st server;
3899 memcached_server_clone(&server, &memc->hosts[0]);
3900 assert(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
3901
3902 memcached_st tcp_client;
3903 memcached_create(&tcp_client);
3904 assert(memcached_server_add_udp(&tcp_client, server.hostname, server.port) == MEMCACHED_INVALID_HOST_PROTOCOL);
3905 return TEST_SUCCESS;
3906 }
3907
3908 static test_return set_udp_behavior_test(memcached_st *memc)
3909 {
3910
3911 memcached_quit(memc);
3912 memc->number_of_hosts= 0;
3913 run_distribution(memc);
3914 assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1) == MEMCACHED_SUCCESS);
3915 assert(memc->flags & MEM_USE_UDP);
3916 assert(memc->flags & MEM_NOREPLY);;
3917
3918 assert(memc->number_of_hosts == 0);
3919
3920 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP,0);
3921 assert(!(memc->flags & MEM_USE_UDP));
3922 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY,0);
3923 assert(!(memc->flags & MEM_NOREPLY));
3924 return TEST_SUCCESS;
3925 }
3926
3927 static test_return udp_set_test(memcached_st *memc)
3928 {
3929 unsigned int x= 0;
3930 unsigned int num_iters= 1025; //request id rolls over at 1024
3931 for (x= 0; x < num_iters;x++)
3932 {
3933 memcached_return rc;
3934 const char *key= "foo";
3935 const char *value= "when we sanitize";
3936 uint16_t *expected_ids= get_udp_request_ids(memc);
3937 unsigned int server_key= memcached_generate_hash(memc,key,strlen(key));
3938 size_t init_offset= memc->hosts[server_key].write_buffer_offset;
3939 rc= memcached_set(memc, key, strlen(key),
3940 value, strlen(value),
3941 (time_t)0, (uint32_t)0);
3942 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
3943 /** NB, the check below assumes that if new write_ptr is less than
3944 * the original write_ptr that we have flushed. For large payloads, this
3945 * maybe an invalid assumption, but for the small payload we have it is OK
3946 */
3947 if (rc == MEMCACHED_SUCCESS ||
3948 memc->hosts[server_key].write_buffer_offset < init_offset)
3949 increment_request_id(&expected_ids[server_key]);
3950
3951 if (rc == MEMCACHED_SUCCESS)
3952 {
3953 assert(memc->hosts[server_key].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
3954 }
3955 else
3956 {
3957 assert(memc->hosts[server_key].write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
3958 assert(memc->hosts[server_key].write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
3959 }
3960 assert(post_udp_op_check(memc,expected_ids) == TEST_SUCCESS);
3961 }
3962 return TEST_SUCCESS;
3963 }
3964
3965 static test_return udp_buffered_set_test(memcached_st *memc)
3966 {
3967 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
3968 return udp_set_test(memc);
3969 }
3970
3971 static test_return udp_set_too_big_test(memcached_st *memc)
3972 {
3973 memcached_return rc;
3974 const char *key= "bar";
3975 char value[MAX_UDP_DATAGRAM_LENGTH];
3976 uint16_t *expected_ids= get_udp_request_ids(memc);
3977 rc= memcached_set(memc, key, strlen(key),
3978 value, MAX_UDP_DATAGRAM_LENGTH,
3979 (time_t)0, (uint32_t)0);
3980 assert(rc == MEMCACHED_WRITE_FAILURE);
3981 return post_udp_op_check(memc,expected_ids);
3982 }
3983
3984 static test_return udp_delete_test(memcached_st *memc)
3985 {
3986 unsigned int x= 0;
3987 unsigned int num_iters= 1025; //request id rolls over at 1024
3988 for (x= 0; x < num_iters;x++)
3989 {
3990 memcached_return rc;
3991 const char *key= "foo";
3992 uint16_t *expected_ids=get_udp_request_ids(memc);
3993 unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
3994 size_t init_offset= memc->hosts[server_key].write_buffer_offset;
3995 rc= memcached_delete(memc, key, strlen(key), 0);
3996 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
3997 if (rc == MEMCACHED_SUCCESS || memc->hosts[server_key].write_buffer_offset < init_offset)
3998 increment_request_id(&expected_ids[server_key]);
3999 if (rc == MEMCACHED_SUCCESS)
4000 assert(memc->hosts[server_key].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
4001 else
4002 {
4003 assert(memc->hosts[server_key].write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
4004 assert(memc->hosts[server_key].write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
4005 }
4006 assert(post_udp_op_check(memc,expected_ids) == TEST_SUCCESS);
4007 }
4008 return TEST_SUCCESS;
4009 }
4010
4011 static test_return udp_buffered_delete_test(memcached_st *memc)
4012 {
4013 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
4014 return udp_delete_test(memc);
4015 }
4016
4017 static test_return udp_verbosity_test(memcached_st *memc)
4018 {
4019 memcached_return rc;
4020 uint16_t *expected_ids= get_udp_request_ids(memc);
4021 unsigned int x;
4022 for (x= 0; x < memc->number_of_hosts;x++)
4023 increment_request_id(&expected_ids[x]);
4024
4025 rc= memcached_verbosity(memc,3);
4026 assert(rc == MEMCACHED_SUCCESS);
4027 return post_udp_op_check(memc,expected_ids);
4028 }
4029
4030 static test_return udp_quit_test(memcached_st *memc)
4031 {
4032 uint16_t *expected_ids= get_udp_request_ids(memc);
4033 memcached_quit(memc);
4034 return post_udp_op_check(memc, expected_ids);
4035 }
4036
4037 static test_return udp_flush_test(memcached_st *memc)
4038 {
4039 memcached_return rc;
4040 uint16_t *expected_ids= get_udp_request_ids(memc);
4041 unsigned int x;
4042 for (x= 0; x < memc->number_of_hosts;x++)
4043 increment_request_id(&expected_ids[x]);
4044
4045 rc= memcached_flush(memc,0);
4046 assert(rc == MEMCACHED_SUCCESS);
4047 return post_udp_op_check(memc,expected_ids);
4048 }
4049
4050 static test_return udp_incr_test(memcached_st *memc)
4051 {
4052 memcached_return rc;
4053 const char *key= "incr";
4054 const char *value= "1";
4055 rc= memcached_set(memc, key, strlen(key),
4056 value, strlen(value),
4057 (time_t)0, (uint32_t)0);
4058
4059 assert(rc == MEMCACHED_SUCCESS);
4060 uint16_t *expected_ids= get_udp_request_ids(memc);
4061 unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
4062 increment_request_id(&expected_ids[server_key]);
4063 uint64_t newvalue;
4064 rc= memcached_increment(memc, key, strlen(key), 1, &newvalue);
4065 assert(rc == MEMCACHED_SUCCESS);
4066 return post_udp_op_check(memc, expected_ids);
4067 }
4068
4069 static test_return udp_decr_test(memcached_st *memc)
4070 {
4071 memcached_return rc;
4072 const char *key= "decr";
4073 const char *value= "1";
4074 rc= memcached_set(memc, key, strlen(key),
4075 value, strlen(value),
4076 (time_t)0, (uint32_t)0);
4077
4078 assert(rc == MEMCACHED_SUCCESS);
4079 uint16_t *expected_ids= get_udp_request_ids(memc);
4080 unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
4081 increment_request_id(&expected_ids[server_key]);
4082 uint64_t newvalue;
4083 rc= memcached_decrement(memc, key, strlen(key), 1, &newvalue);
4084 assert(rc == MEMCACHED_SUCCESS);
4085 return post_udp_op_check(memc, expected_ids);
4086 }
4087
4088
4089 static test_return udp_stat_test(memcached_st *memc)
4090 {
4091 memcached_stat_st * rv= NULL;
4092 memcached_return rc;
4093 char args[]= "";
4094 uint16_t *expected_ids = get_udp_request_ids(memc);
4095 rv = memcached_stat(memc, args, &rc);
4096 free(rv);
4097 assert(rc == MEMCACHED_NOT_SUPPORTED);
4098 return post_udp_op_check(memc, expected_ids);
4099 }
4100
4101 static test_return udp_version_test(memcached_st *memc)
4102 {
4103 memcached_return rc;
4104 uint16_t *expected_ids = get_udp_request_ids(memc);
4105 rc = memcached_version(memc);
4106 assert(rc == MEMCACHED_NOT_SUPPORTED);
4107 return post_udp_op_check(memc, expected_ids);
4108 }
4109
4110 static test_return udp_get_test(memcached_st *memc)
4111 {
4112 memcached_return rc;
4113 const char *key= "foo";
4114 size_t vlen;
4115 uint16_t *expected_ids = get_udp_request_ids(memc);
4116 char *val= memcached_get(memc, key, strlen(key), &vlen, (uint32_t)0, &rc);
4117 assert(rc == MEMCACHED_NOT_SUPPORTED);
4118 assert(val == NULL);
4119 return post_udp_op_check(memc, expected_ids);
4120 }
4121
4122 static test_return udp_mixed_io_test(memcached_st *memc)
4123 {
4124 test_st current_op;
4125 test_st mixed_io_ops [] ={
4126 {"udp_set_test", 0, udp_set_test},
4127 {"udp_set_too_big_test", 0, udp_set_too_big_test},
4128 {"udp_delete_test", 0, udp_delete_test},
4129 {"udp_verbosity_test", 0, udp_verbosity_test},
4130 {"udp_quit_test", 0, udp_quit_test},
4131 {"udp_flush_test", 0, udp_flush_test},
4132 {"udp_incr_test", 0, udp_incr_test},
4133 {"udp_decr_test", 0, udp_decr_test},
4134 {"udp_version_test", 0, udp_version_test}
4135 };
4136 unsigned int x= 0;
4137 for (x= 0; x < 500; x++)
4138 {
4139 current_op= mixed_io_ops[random() % 9];
4140 assert(current_op.function(memc) == TEST_SUCCESS);
4141 }
4142 return TEST_SUCCESS;
4143 }
4144
4145 static test_return hsieh_avaibility_test (memcached_st *memc)
4146 {
4147 memcached_return expected_rc= MEMCACHED_FAILURE;
4148 #ifdef HAVE_HSIEH_HASH
4149 expected_rc= MEMCACHED_SUCCESS;
4150 #endif
4151 memcached_return rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
4152 (uint64_t)MEMCACHED_HASH_HSIEH);
4153 assert(rc == expected_rc);
4154 return TEST_SUCCESS;
4155 }
4156
4157 static const char *list[]=
4158 {
4159 "apple",
4160 "beat",
4161 "carrot",
4162 "daikon",
4163 "eggplant",
4164 "flower",
4165 "green",
4166 "hide",
4167 "ick",
4168 "jack",
4169 "kick",
4170 "lime",
4171 "mushrooms",
4172 "nectarine",
4173 "orange",
4174 "peach",
4175 "quant",
4176 "ripen",
4177 "strawberry",
4178 "tang",
4179 "up",
4180 "volumne",
4181 "when",
4182 "yellow",
4183 "zip",
4184 NULL
4185 };
4186
4187 static test_return md5_run (memcached_st *memc __attribute__((unused)))
4188 {
4189 uint32_t x;
4190 const char **ptr;
4191 uint32_t values[]= { 3195025439U, 2556848621U, 3724893440U, 3332385401U,
4192 245758794U, 2550894432U, 121710495U, 3053817768U,
4193 1250994555U, 1862072655U, 2631955953U, 2951528551U,
4194 1451250070U, 2820856945U, 2060845566U, 3646985608U,
4195 2138080750U, 217675895U, 2230934345U, 1234361223U,
4196 3968582726U, 2455685270U, 1293568479U, 199067604U,
4197 2042482093U };
4198
4199
4200 for (ptr= list, x= 0; *ptr; ptr++, x++)
4201 {
4202 uint32_t hash_val;
4203
4204 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5);
4205 assert(values[x] == hash_val);
4206 }
4207
4208 return TEST_SUCCESS;
4209 }
4210
4211 static test_return crc_run (memcached_st *memc __attribute__((unused)))
4212 {
4213 uint32_t x;
4214 const char **ptr;
4215 uint32_t values[]= { 10542U, 22009U, 14526U, 19510U, 19432U, 10199U, 20634U,
4216 9369U, 11511U, 10362U, 7893U, 31289U, 11313U, 9354U,
4217 7621U, 30628U, 15218U, 25967U, 2695U, 9380U,
4218 17300U, 28156U, 9192U, 20484U, 16925U };
4219
4220 for (ptr= list, x= 0; *ptr; ptr++, x++)
4221 {
4222 uint32_t hash_val;
4223
4224 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC);
4225 assert(values[x] == hash_val);
4226 }
4227
4228 return TEST_SUCCESS;
4229 }
4230
4231 static test_return fnv1_64_run (memcached_st *memc __attribute__((unused)))
4232 {
4233 uint32_t x;
4234 const char **ptr;
4235 uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
4236 1722477987U, 2991193800U, 4147007314U, 3633179701U,
4237 1805162104U, 3503289120U, 3395702895U, 3325073042U,
4238 2345265314U, 3340346032U, 2722964135U, 1173398992U,
4239 2815549194U, 2562818319U, 224996066U, 2680194749U,
4240 3035305390U, 246890365U, 2395624193U, 4145193337U,
4241 1801941682U };
4242
4243 for (ptr= list, x= 0; *ptr; ptr++, x++)
4244 {
4245 uint32_t hash_val;
4246
4247 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
4248 assert(values[x] == hash_val);
4249 }
4250
4251 return TEST_SUCCESS;
4252 }
4253
4254 static test_return fnv1a_64_run (memcached_st *memc __attribute__((unused)))
4255 {
4256 uint32_t x;
4257 const char **ptr;
4258 uint32_t values[]= { 1488911807U, 2500855813U, 1510099634U, 1390325195U,
4259 3647689787U, 3241528582U, 1669328060U, 2604311949U,
4260 734810122U, 1516407546U, 560948863U, 1767346780U,
4261 561034892U, 4156330026U, 3716417003U, 3475297030U,
4262 1518272172U, 227211583U, 3938128828U, 126112909U,
4263 3043416448U, 3131561933U, 1328739897U, 2455664041U,
4264 2272238452U };
4265
4266 for (ptr= list, x= 0; *ptr; ptr++, x++)
4267 {
4268 uint32_t hash_val;
4269
4270 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64);
4271 assert(values[x] == hash_val);
4272 }
4273
4274 return TEST_SUCCESS;
4275 }
4276
4277 static test_return fnv1_32_run (memcached_st *memc __attribute__((unused)))
4278 {
4279 uint32_t x;
4280 const char **ptr;
4281 uint32_t values[]= { 67176023U, 1190179409U, 2043204404U, 3221866419U,
4282 2567703427U, 3787535528U, 4147287986U, 3500475733U,
4283 344481048U, 3865235296U, 2181839183U, 119581266U,
4284 510234242U, 4248244304U, 1362796839U, 103389328U,
4285 1449620010U, 182962511U, 3554262370U, 3206747549U,
4286 1551306158U, 4127558461U, 1889140833U, 2774173721U,
4287 1180552018U };
4288
4289
4290 for (ptr= list, x= 0; *ptr; ptr++, x++)
4291 {
4292 uint32_t hash_val;
4293
4294 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32);
4295 assert(values[x] == hash_val);
4296 }
4297
4298 return TEST_SUCCESS;
4299 }
4300
4301 static test_return fnv1a_32_run (memcached_st *memc __attribute__((unused)))
4302 {
4303 uint32_t x;
4304 const char **ptr;
4305 uint32_t values[]= { 280767167U, 2421315013U, 3072375666U, 855001899U,
4306 459261019U, 3521085446U, 18738364U, 1625305005U,
4307 2162232970U, 777243802U, 3323728671U, 132336572U,
4308 3654473228U, 260679466U, 1169454059U, 2698319462U,
4309 1062177260U, 235516991U, 2218399068U, 405302637U,
4310 1128467232U, 3579622413U, 2138539289U, 96429129U,
4311 2877453236U };
4312
4313 for (ptr= list, x= 0; *ptr; ptr++, x++)
4314 {
4315 uint32_t hash_val;
4316
4317 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32);
4318 assert(values[x] == hash_val);
4319 }
4320
4321 return TEST_SUCCESS;
4322 }
4323
4324 static test_return hsieh_run (memcached_st *memc __attribute__((unused)))
4325 {
4326 uint32_t x;
4327 const char **ptr;
4328 #ifdef HAVE_HSIEH_HASH
4329 uint32_t values[]= { 3738850110, 3636226060, 3821074029, 3489929160, 3485772682, 80540287,
4330 1805464076, 1895033657, 409795758, 979934958, 3634096985, 1284445480,
4331 2265380744, 707972988, 353823508, 1549198350, 1327930172, 9304163,
4332 4220749037, 2493964934, 2777873870, 2057831732, 1510213931, 2027828987,
4333 3395453351 };
4334 #else
4335 uint32_t values[]= { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
4336 #endif
4337
4338 for (ptr= list, x= 0; *ptr; ptr++, x++)
4339 {
4340 uint32_t hash_val;
4341
4342 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH);
4343 assert(values[x] == hash_val);
4344 }
4345
4346 return TEST_SUCCESS;
4347 }
4348
4349 static test_return murmur_run (memcached_st *memc __attribute__((unused)))
4350 {
4351 uint32_t x;
4352 const char **ptr;
4353 uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
4354 1722477987U, 2991193800U, 4147007314U, 3633179701U,
4355 1805162104U, 3503289120U, 3395702895U, 3325073042U,
4356 2345265314U, 3340346032U, 2722964135U, 1173398992U,
4357 2815549194U, 2562818319U, 224996066U, 2680194749U,
4358 3035305390U, 246890365U, 2395624193U, 4145193337U,
4359 1801941682U };
4360
4361 for (ptr= list, x= 0; *ptr; ptr++, x++)
4362 {
4363 uint32_t hash_val;
4364
4365 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
4366 assert(values[x] == hash_val);
4367 }
4368
4369 return TEST_SUCCESS;
4370 }
4371
4372 static test_return jenkins_run (memcached_st *memc __attribute__((unused)))
4373 {
4374 uint32_t x;
4375 const char **ptr;
4376 uint32_t values[]= { 1442444624U, 4253821186U, 1885058256U, 2120131735U,
4377 3261968576U, 3515188778U, 4232909173U, 4288625128U,
4378 1812047395U, 3689182164U, 2502979932U, 1214050606U,
4379 2415988847U, 1494268927U, 1025545760U, 3920481083U,
4380 4153263658U, 3824871822U, 3072759809U, 798622255U,
4381 3065432577U, 1453328165U, 2691550971U, 3408888387U,
4382 2629893356U };
4383
4384
4385 for (ptr= list, x= 0; *ptr; ptr++, x++)
4386 {
4387 uint32_t hash_val;
4388
4389 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS);
4390 assert(values[x] == hash_val);
4391 }
4392
4393 return TEST_SUCCESS;
4394 }
4395
4396 static test_return regression_bug_434484(memcached_st *memc)
4397 {
4398 if (pre_binary(memc) != TEST_SUCCESS)
4399 return TEST_SUCCESS;
4400
4401 memcached_return ret;
4402 const char *key= "regression_bug_434484";
4403 size_t keylen= strlen(key);
4404
4405 ret= memcached_append(memc, key, keylen, key, keylen, 0, 0);
4406 assert(ret == MEMCACHED_NOTSTORED);
4407
4408 size_t size= 2048 * 1024;
4409 void *data= malloc(size);
4410 assert(data != NULL);
4411 ret= memcached_set(memc, key, keylen, data, size, 0, 0);
4412 assert(ret == MEMCACHED_E2BIG);
4413 free(data);
4414
4415 return TEST_SUCCESS;
4416 }
4417
4418 test_st udp_setup_server_tests[] ={
4419 {"set_udp_behavior_test", 0, set_udp_behavior_test},
4420 {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test},
4421 {"add_udp_server_tcp_client_test", 0, add_udp_server_tcp_client_test},
4422 {0, 0, 0}
4423 };
4424
4425 test_st upd_io_tests[] ={
4426 {"udp_set_test", 0, udp_set_test},
4427 {"udp_buffered_set_test", 0, udp_buffered_set_test},
4428 {"udp_set_too_big_test", 0, udp_set_too_big_test},
4429 {"udp_delete_test", 0, udp_delete_test},
4430 {"udp_buffered_delete_test", 0, udp_buffered_delete_test},
4431 {"udp_verbosity_test", 0, udp_verbosity_test},
4432 {"udp_quit_test", 0, udp_quit_test},
4433 {"udp_flush_test", 0, udp_flush_test},
4434 {"udp_incr_test", 0, udp_incr_test},
4435 {"udp_decr_test", 0, udp_decr_test},
4436 {"udp_stat_test", 0, udp_stat_test},
4437 {"udp_version_test", 0, udp_version_test},
4438 {"udp_get_test", 0, udp_get_test},
4439 {"udp_mixed_io_test", 0, udp_mixed_io_test},
4440 {0, 0, 0}
4441 };
4442
4443 /* Clean the server before beginning testing */
4444 test_st tests[] ={
4445 {"flush", 0, flush_test },
4446 {"init", 0, init_test },
4447 {"allocation", 0, allocation_test },
4448 {"server_list_null_test", 0, server_list_null_test},
4449 {"server_unsort", 0, server_unsort_test},
4450 {"server_sort", 0, server_sort_test},
4451 {"server_sort2", 0, server_sort2_test},
4452 {"clone_test", 0, clone_test },
4453 {"connection_test", 0, connection_test},
4454 {"callback_test", 0, callback_test},
4455 {"behavior_test", 0, behavior_test},
4456 {"userdata_test", 0, userdata_test},
4457 {"error", 0, error_test },
4458 {"set", 0, set_test },
4459 {"set2", 0, set_test2 },
4460 {"set3", 0, set_test3 },
4461 {"dump", 1, dump_test},
4462 {"add", 1, add_test },
4463 {"replace", 1, replace_test },
4464 {"delete", 1, delete_test },
4465 {"get", 1, get_test },
4466 {"get2", 0, get_test2 },
4467 {"get3", 0, get_test3 },
4468 {"get4", 0, get_test4 },
4469 {"partial mget", 0, get_test5 },
4470 {"stats_servername", 0, stats_servername_test },
4471 {"increment", 0, increment_test },
4472 {"increment_with_initial", 1, increment_with_initial_test },
4473 {"decrement", 0, decrement_test },
4474 {"decrement_with_initial", 1, decrement_with_initial_test },
4475 {"quit", 0, quit_test },
4476 {"mget", 1, mget_test },
4477 {"mget_result", 1, mget_result_test },
4478 {"mget_result_alloc", 1, mget_result_alloc_test },
4479 {"mget_result_function", 1, mget_result_function },
4480 {"get_stats", 0, get_stats },
4481 {"add_host_test", 0, add_host_test },
4482 {"add_host_test_1", 0, add_host_test1 },
4483 {"get_stats_keys", 0, get_stats_keys },
4484 {"behavior_test", 0, get_stats_keys },
4485 {"callback_test", 0, get_stats_keys },
4486 {"version_string_test", 0, version_string_test},
4487 {"bad_key", 1, bad_key_test },
4488 {"memcached_server_cursor", 1, memcached_server_cursor_test },
4489 {"read_through", 1, read_through },
4490 {"delete_through", 1, delete_through },
4491 {"noreply", 1, noreply_test},
4492 {"analyzer", 1, analyzer_test},
4493 #ifdef HAVE_LIBMEMCACHEDUTIL
4494 {"connectionpool", 1, connection_pool_test },
4495 #endif
4496 {0, 0, 0}
4497 };
4498
4499 test_st async_tests[] ={
4500 {"add", 1, add_wrapper },
4501 {0, 0, 0}
4502 };
4503
4504 test_st string_tests[] ={
4505 {"string static with null", 0, string_static_null },
4506 {"string alloc with null", 0, string_alloc_null },
4507 {"string alloc with 1K", 0, string_alloc_with_size },
4508 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
4509 {"string append", 0, string_alloc_append },
4510 {"string append failure (too big)", 0, string_alloc_append_toobig },
4511 {0, 0, 0}
4512 };
4513
4514 test_st result_tests[] ={
4515 {"result static", 0, result_static},
4516 {"result alloc", 0, result_alloc},
4517 {0, 0, 0}
4518 };
4519
4520 test_st version_1_2_3[] ={
4521 {"append", 0, append_test },
4522 {"prepend", 0, prepend_test },
4523 {"cas", 0, cas_test },
4524 {"cas2", 0, cas2_test },
4525 {"append_binary", 0, append_binary_test },
4526 {0, 0, 0}
4527 };
4528
4529 test_st user_tests[] ={
4530 {"user_supplied_bug1", 0, user_supplied_bug1 },
4531 {"user_supplied_bug2", 0, user_supplied_bug2 },
4532 {"user_supplied_bug3", 0, user_supplied_bug3 },
4533 {"user_supplied_bug4", 0, user_supplied_bug4 },
4534 {"user_supplied_bug5", 1, user_supplied_bug5 },
4535 {"user_supplied_bug6", 1, user_supplied_bug6 },
4536 {"user_supplied_bug7", 1, user_supplied_bug7 },
4537 {"user_supplied_bug8", 1, user_supplied_bug8 },
4538 {"user_supplied_bug9", 1, user_supplied_bug9 },
4539 {"user_supplied_bug10", 1, user_supplied_bug10 },
4540 {"user_supplied_bug11", 1, user_supplied_bug11 },
4541 {"user_supplied_bug12", 1, user_supplied_bug12 },
4542 {"user_supplied_bug13", 1, user_supplied_bug13 },
4543 {"user_supplied_bug14", 1, user_supplied_bug14 },
4544 {"user_supplied_bug15", 1, user_supplied_bug15 },
4545 {"user_supplied_bug16", 1, user_supplied_bug16 },
4546 #ifndef __sun
4547 /*
4548 ** It seems to be something weird with the character sets..
4549 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
4550 ** guess I need to find out how this is supposed to work.. Perhaps I need
4551 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
4552 ** so just disable the code for now...).
4553 */
4554 {"user_supplied_bug17", 1, user_supplied_bug17 },
4555 #endif
4556 {"user_supplied_bug18", 1, user_supplied_bug18 },
4557 {"user_supplied_bug19", 1, user_supplied_bug19 },
4558 {"user_supplied_bug20", 1, user_supplied_bug20 },
4559 {0, 0, 0}
4560 };
4561
4562 test_st replication_tests[]= {
4563 {"set", 1, replication_set_test },
4564 {"get", 0, replication_get_test },
4565 {"mget", 0, replication_mget_test },
4566 {"delete", 0, replication_delete_test },
4567 {0, 0, 0}
4568 };
4569
4570 /*
4571 * The following test suite is used to verify that we don't introduce
4572 * regression bugs. If you want more information about the bug / test,
4573 * you should look in the bug report at
4574 * http://bugs.launchpad.net/libmemcached
4575 */
4576 test_st regression_tests[]= {
4577 {"lp:434484", 1, regression_bug_434484 },
4578 {0, 0, 0}
4579 };
4580
4581 test_st generate_tests[] ={
4582 {"generate_pairs", 1, generate_pairs },
4583 {"generate_data", 1, generate_data },
4584 {"get_read", 0, get_read },
4585 {"delete_generate", 0, delete_generate },
4586 {"generate_buffer_data", 1, generate_buffer_data },
4587 {"delete_buffer", 0, delete_buffer_generate},
4588 {"generate_data", 1, generate_data },
4589 {"mget_read", 0, mget_read },
4590 {"mget_read_result", 0, mget_read_result },
4591 {"mget_read_function", 0, mget_read_function },
4592 {"cleanup", 1, cleanup_pairs },
4593 {"generate_large_pairs", 1, generate_large_pairs },
4594 {"generate_data", 1, generate_data },
4595 {"generate_buffer_data", 1, generate_buffer_data },
4596 {"cleanup", 1, cleanup_pairs },
4597 {0, 0, 0}
4598 };
4599
4600 test_st consistent_tests[] ={
4601 {"generate_pairs", 1, generate_pairs },
4602 {"generate_data", 1, generate_data },
4603 {"get_read", 0, get_read_count },
4604 {"cleanup", 1, cleanup_pairs },
4605 {0, 0, 0}
4606 };
4607
4608 test_st consistent_weighted_tests[] ={
4609 {"generate_pairs", 1, generate_pairs },
4610 {"generate_data", 1, generate_data_with_stats },
4611 {"get_read", 0, get_read_count },
4612 {"cleanup", 1, cleanup_pairs },
4613 {0, 0, 0}
4614 };
4615
4616 test_st hsieh_availability[] ={
4617 {"hsieh_avaibility_test",0,hsieh_avaibility_test},
4618 {0, 0, 0}
4619 };
4620
4621 test_st ketama_auto_eject_hosts[] ={
4622 {"auto_eject_hosts", 1, auto_eject_hosts },
4623 {0, 0, 0}
4624 };
4625
4626 test_st hash_tests[] ={
4627 {"md5", 0, md5_run },
4628 {"crc", 0, crc_run },
4629 {"fnv1_64", 0, fnv1_64_run },
4630 {"fnv1a_64", 0, fnv1a_64_run },
4631 {"fnv1_32", 0, fnv1_32_run },
4632 {"fnv1a_32", 0, fnv1a_32_run },
4633 {"hsieh", 0, hsieh_run },
4634 {"murmur", 0, murmur_run },
4635 {"jenkis", 0, jenkins_run },
4636 {0, 0, 0}
4637 };
4638
4639 collection_st collection[] ={
4640 {"hsieh_availability",0,0,hsieh_availability},
4641 {"udp_setup", init_udp, 0, udp_setup_server_tests},
4642 {"udp_io", init_udp, 0, upd_io_tests},
4643 {"udp_binary_io", binary_init_udp, 0, upd_io_tests},
4644 {"block", 0, 0, tests},
4645 {"binary", pre_binary, 0, tests},
4646 {"nonblock", pre_nonblock, 0, tests},
4647 {"nodelay", pre_nodelay, 0, tests},
4648 {"settimer", pre_settimer, 0, tests},
4649 {"md5", pre_md5, 0, tests},
4650 {"crc", pre_crc, 0, tests},
4651 {"hsieh", pre_hsieh, 0, tests},
4652 {"jenkins", pre_jenkins, 0, tests},
4653 {"fnv1_64", pre_hash_fnv1_64, 0, tests},
4654 {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
4655 {"fnv1_32", pre_hash_fnv1_32, 0, tests},
4656 {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
4657 {"ketama", pre_behavior_ketama, 0, tests},
4658 {"ketama_auto_eject_hosts", pre_behavior_ketama, 0, ketama_auto_eject_hosts},
4659 {"unix_socket", pre_unix_socket, 0, tests},
4660 {"unix_socket_nodelay", pre_nodelay, 0, tests},
4661 {"poll_timeout", poll_timeout, 0, tests},
4662 {"gets", enable_cas, 0, tests},
4663 {"consistent", enable_consistent, 0, tests},
4664 #ifdef MEMCACHED_ENABLE_DEPRECATED
4665 {"deprecated_memory_allocators", deprecated_set_memory_alloc, 0, tests},
4666 #endif
4667 {"memory_allocators", set_memory_alloc, 0, tests},
4668 {"prefix", set_prefix, 0, tests},
4669 {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
4670 {"string", 0, 0, string_tests},
4671 {"result", 0, 0, result_tests},
4672 {"async", pre_nonblock, 0, async_tests},
4673 {"async_binary", pre_nonblock_binary, 0, async_tests},
4674 {"user", 0, 0, user_tests},
4675 {"generate", 0, 0, generate_tests},
4676 {"generate_hsieh", pre_hsieh, 0, generate_tests},
4677 {"generate_ketama", pre_behavior_ketama, 0, generate_tests},
4678 {"generate_hsieh_consistent", enable_consistent, 0, generate_tests},
4679 {"generate_md5", pre_md5, 0, generate_tests},
4680 {"generate_murmur", pre_murmur, 0, generate_tests},
4681 {"generate_jenkins", pre_jenkins, 0, generate_tests},
4682 {"generate_nonblock", pre_nonblock, 0, generate_tests},
4683 {"consistent_not", 0, 0, consistent_tests},
4684 {"consistent_ketama", pre_behavior_ketama, 0, consistent_tests},
4685 {"consistent_ketama_weighted", pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
4686 {"test_hashes", 0, 0, hash_tests},
4687 {"replication", pre_replication, 0, replication_tests},
4688 {"replication_noblock", pre_replication_noblock, 0, replication_tests},
4689 {"regression", 0, 0, regression_tests},
4690 {0, 0, 0, 0}
4691 };
4692
4693 #define SERVERS_TO_CREATE 5
4694
4695 /* Prototypes for functions we will pass to test framework */
4696 void *world_create(void);
4697 void world_destroy(void *p);
4698
4699 void *world_create(void)
4700 {
4701 server_startup_st *construct;
4702
4703 construct= (server_startup_st *)malloc(sizeof(server_startup_st));
4704 memset(construct, 0, sizeof(server_startup_st));
4705 construct->count= SERVERS_TO_CREATE;
4706 construct->udp= 0;
4707 server_startup(construct);
4708
4709 return construct;
4710 }
4711
4712
4713 void world_destroy(void *p)
4714 {
4715 server_startup_st *construct= (server_startup_st *)p;
4716 memcached_server_st *servers= (memcached_server_st *)construct->servers;
4717 memcached_server_list_free(servers);
4718
4719 server_shutdown(construct);
4720 free(construct);
4721 }
4722
4723 void get_world(world_st *world)
4724 {
4725 world->collections= collection;
4726 world->create= world_create;
4727 world->destroy= world_destroy;
4728 }