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