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