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