git.m6w6.name Git - m6w6/libmemcached/blob - tests/mem_functions.c

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