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

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