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