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   free(mem);
3554 }
3555
3556 static void *my_malloc(memcached_st *ptr __attribute__((unused)), const size_t size)
3557 {
3558   void *ret= malloc(size);
3559   if (ret != NULL)
3560     memset(ret, 0xff, size);
3561
3562   return ret;
3563 }
3564
3565 static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, const size_t size)
3566 {
3567   return realloc(mem, size);
3568 }
3569
3570 static void *my_calloc(memcached_st *ptr __attribute__((unused)), size_t nelem, const size_t size)
3571 {
3572   return calloc(nelem, size);
3573 }
3574
3575 static test_return_t set_prefix(memcached_st *memc)
3576 {
3577   memcached_return_t rc;
3578   const char *key= "mine";
3579   char *value;
3580
3581   /* Make sure be default none exists */
3582   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3583   test_truth(rc == MEMCACHED_FAILURE);
3584
3585   /* Test a clean set */
3586   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3587   test_truth(rc == MEMCACHED_SUCCESS);
3588
3589   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3590   test_truth(memcmp(value, key, 4) == 0);
3591   test_truth(rc == MEMCACHED_SUCCESS);
3592
3593   /* Test that we can turn it off */
3594   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3595   test_truth(rc == MEMCACHED_SUCCESS);
3596
3597   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3598   test_truth(rc == MEMCACHED_FAILURE);
3599
3600   /* Now setup for main test */
3601   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3602   test_truth(rc == MEMCACHED_SUCCESS);
3603
3604   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3605   test_truth(rc == MEMCACHED_SUCCESS);
3606   test_truth(memcmp(value, key, 4) == 0);
3607
3608   /* Set to Zero, and then Set to something too large */
3609   {
3610     char long_key[255];
3611     memset(long_key, 0, 255);
3612
3613     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3614     test_truth(rc == MEMCACHED_SUCCESS);
3615
3616     value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3617     test_truth(rc == MEMCACHED_FAILURE);
3618     test_truth(value == NULL);
3619
3620     /* Test a long key for failure */
3621     /* TODO, extend test to determine based on setting, what result should be */
3622     strcpy(long_key, "Thisismorethentheallottednumberofcharacters");
3623     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3624     //test_truth(rc == MEMCACHED_BAD_KEY_PROVIDED);
3625     test_truth(rc == MEMCACHED_SUCCESS);
3626
3627     /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3628     strcpy(long_key, "This is more then the allotted number of characters");
3629     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3630     test_truth(rc == MEMCACHED_BAD_KEY_PROVIDED);
3631
3632     /* Test for a bad prefix, but with a short key */
3633     rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
3634     test_truth(rc == MEMCACHED_SUCCESS);
3635
3636     strcpy(long_key, "dog cat");
3637     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3638     test_truth(rc == MEMCACHED_BAD_KEY_PROVIDED);
3639   }
3640
3641   return TEST_SUCCESS;
3642 }
3643
3644 #ifdef MEMCACHED_ENABLE_DEPRECATED
3645 static test_return_t deprecated_set_memory_alloc(memcached_st *memc)
3646 {
3647   void *test_ptr= NULL;
3648   void *cb_ptr= NULL;
3649   {
3650     memcached_malloc_fn malloc_cb=
3651       (memcached_malloc_fn)my_malloc;
3652     cb_ptr= *(void **)&malloc_cb;
3653     memcached_return_t rc;
3654
3655     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, cb_ptr);
3656     test_truth(rc == MEMCACHED_SUCCESS);
3657     test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
3658     test_truth(rc == MEMCACHED_SUCCESS);
3659     test_truth(test_ptr == cb_ptr);
3660   }
3661
3662   {
3663     memcached_realloc_fn realloc_cb=
3664       (memcached_realloc_fn)my_realloc;
3665     cb_ptr= *(void **)&realloc_cb;
3666     memcached_return_t rc;
3667
3668     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, cb_ptr);
3669     test_truth(rc == MEMCACHED_SUCCESS);
3670     test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
3671     test_truth(rc == MEMCACHED_SUCCESS);
3672     test_truth(test_ptr == cb_ptr);
3673   }
3674
3675   {
3676     memcached_free_fn free_cb=
3677       (memcached_free_fn)my_free;
3678     cb_ptr= *(void **)&free_cb;
3679     memcached_return_t rc;
3680
3681     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, cb_ptr);
3682     test_truth(rc == MEMCACHED_SUCCESS);
3683     test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
3684     test_truth(rc == MEMCACHED_SUCCESS);
3685     test_truth(test_ptr == cb_ptr);
3686   }
3687
3688   return TEST_SUCCESS;
3689 }
3690 #endif
3691
3692 static test_return_t set_memory_alloc(memcached_st *memc)
3693 {
3694   memcached_return_t rc;
3695   rc= memcached_set_memory_allocators(memc, NULL, my_free,
3696                                       my_realloc, my_calloc);
3697   test_truth(rc == MEMCACHED_FAILURE);
3698
3699   rc= memcached_set_memory_allocators(memc, my_malloc, my_free,
3700                                       my_realloc, my_calloc);
3701
3702   memcached_malloc_fn mem_malloc;
3703   memcached_free_fn mem_free;
3704   memcached_realloc_fn mem_realloc;
3705   memcached_calloc_fn mem_calloc;
3706   memcached_get_memory_allocators(memc, &mem_malloc, &mem_free,
3707                                   &mem_realloc, &mem_calloc);
3708
3709   test_truth(mem_malloc == my_malloc);
3710   test_truth(mem_realloc == my_realloc);
3711   test_truth(mem_calloc == my_calloc);
3712   test_truth(mem_free == my_free);
3713
3714   return TEST_SUCCESS;
3715 }
3716
3717 static test_return_t enable_consistent(memcached_st *memc)
3718 {
3719   test_return_t rc;
3720   memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
3721   memcached_hash_t hash;
3722   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
3723   if ((rc= pre_hsieh(memc)) != TEST_SUCCESS)
3724     return rc;
3725
3726   value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
3727   test_truth(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
3728
3729   hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
3730
3731   if (hash != MEMCACHED_HASH_HSIEH)
3732     return TEST_SKIPPED;
3733
3734
3735   return TEST_SUCCESS;
3736 }
3737
3738 static test_return_t enable_cas(memcached_st *memc)
3739 {
3740   unsigned int set= 1;
3741
3742   memcached_version(memc);
3743
3744   if ((memc->hosts[0].major_version >= 1 && (memc->hosts[0].minor_version == 2 && memc->hosts[0].micro_version >= 4))
3745       || memc->hosts[0].minor_version > 2)
3746   {
3747     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
3748
3749     return TEST_SUCCESS;
3750   }
3751
3752   return TEST_SKIPPED;
3753 }
3754
3755 static test_return_t  check_for_1_2_3(memcached_st *memc)
3756 {
3757   memcached_version(memc);
3758
3759   if ((memc->hosts[0].major_version >= 1 && (memc->hosts[0].minor_version == 2 && memc->hosts[0].micro_version >= 4))
3760       || memc->hosts[0].minor_version > 2)
3761     return TEST_SUCCESS;
3762
3763   return TEST_SKIPPED;
3764 }
3765
3766 static test_return_t  pre_unix_socket(memcached_st *memc)
3767 {
3768   memcached_return_t rc;
3769   struct stat buf;
3770
3771   memcached_server_list_free(memc->hosts);
3772   memc->hosts= NULL;
3773   memc->number_of_hosts= 0;
3774
3775   if (stat("/tmp/memcached.socket", &buf))
3776     return TEST_SKIPPED;
3777
3778   rc= memcached_server_add_unix_socket_with_weight(memc, "/tmp/memcached.socket", 0);
3779
3780   return ( rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_FAILURE );
3781 }
3782
3783 static test_return_t  pre_nodelay(memcached_st *memc)
3784 {
3785   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
3786   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
3787
3788   return TEST_SUCCESS;
3789 }
3790
3791 static test_return_t  pre_settimer(memcached_st *memc)
3792 {
3793   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
3794   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
3795
3796   return TEST_SUCCESS;
3797 }
3798
3799 static test_return_t  poll_timeout(memcached_st *memc)
3800 {
3801   size_t timeout;
3802
3803   timeout= 100;
3804
3805   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
3806
3807   timeout= (size_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
3808
3809   test_truth(timeout == 100);
3810
3811   return TEST_SUCCESS;
3812 }
3813
3814 static test_return_t noreply_test(memcached_st *memc)
3815 {
3816   memcached_return_t ret;
3817   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
3818   test_truth(ret == MEMCACHED_SUCCESS);
3819   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
3820   test_truth(ret == MEMCACHED_SUCCESS);
3821   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
3822   test_truth(ret == MEMCACHED_SUCCESS);
3823   test_truth(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY) == 1);
3824   test_truth(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS) == 1);
3825   test_truth(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS) == 1);
3826
3827   for (int count=0; count < 5; ++count)
3828   {
3829     for (int x=0; x < 100; ++x)
3830     {
3831       char key[10];
3832       size_t len= (size_t)sprintf(key, "%d", x);
3833       switch (count)
3834       {
3835       case 0:
3836         ret= memcached_add(memc, key, len, key, len, 0, 0);
3837         break;
3838       case 1:
3839         ret= memcached_replace(memc, key, len, key, len, 0, 0);
3840         break;
3841       case 2:
3842         ret= memcached_set(memc, key, len, key, len, 0, 0);
3843         break;
3844       case 3:
3845         ret= memcached_append(memc, key, len, key, len, 0, 0);
3846         break;
3847       case 4:
3848         ret= memcached_prepend(memc, key, len, key, len, 0, 0);
3849         break;
3850       default:
3851         test_truth(count);
3852         break;
3853       }
3854       test_truth(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED);
3855     }
3856
3857     /*
3858     ** NOTE: Don't ever do this in your code! this is not a supported use of the
3859     ** API and is _ONLY_ done this way to verify that the library works the
3860     ** way it is supposed to do!!!!
3861     */
3862     int no_msg=0;
3863     for (uint32_t x=0; x < memc->number_of_hosts; ++x)
3864       no_msg+=(int)(memc->hosts[x].cursor_active);
3865
3866     test_truth(no_msg == 0);
3867     test_truth(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
3868
3869     /*
3870      ** Now validate that all items was set properly!
3871      */
3872     for (int x=0; x < 100; ++x)
3873     {
3874       char key[10];
3875       size_t len= (size_t)sprintf(key, "%d", x);
3876       size_t length;
3877       uint32_t flags;
3878       char* value=memcached_get(memc, key, strlen(key),
3879                                 &length, &flags, &ret);
3880       test_truth(ret == MEMCACHED_SUCCESS && value != NULL);
3881       switch (count)
3882       {
3883       case 0: /* FALLTHROUGH */
3884       case 1: /* FALLTHROUGH */
3885       case 2:
3886         test_truth(strncmp(value, key, len) == 0);
3887         test_truth(len == length);
3888         break;
3889       case 3:
3890         test_truth(length == len * 2);
3891         break;
3892       case 4:
3893         test_truth(length == len * 3);
3894         break;
3895       default:
3896         test_truth(count);
3897         break;
3898       }
3899       free(value);
3900     }
3901   }
3902
3903   /* Try setting an illegal cas value (should not return an error to
3904    * the caller (because we don't expect a return message from the server)
3905    */
3906   const char* keys[]= {"0"};
3907   size_t lengths[]= {1};
3908   size_t length;
3909   uint32_t flags;
3910   memcached_result_st results_obj;
3911   memcached_result_st *results;
3912   ret= memcached_mget(memc, keys, lengths, 1);
3913   test_truth(ret == MEMCACHED_SUCCESS);
3914
3915   results= memcached_result_create(memc, &results_obj);
3916   test_truth(results);
3917   results= memcached_fetch_result(memc, &results_obj, &ret);
3918   test_truth(results);
3919   test_truth(ret == MEMCACHED_SUCCESS);
3920   uint64_t cas= memcached_result_cas(results);
3921   memcached_result_free(&results_obj);
3922
3923   ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
3924   test_truth(ret == MEMCACHED_SUCCESS);
3925
3926   /*
3927    * The item will have a new cas value, so try to set it again with the old
3928    * value. This should fail!
3929    */
3930   ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
3931   test_truth(ret == MEMCACHED_SUCCESS);
3932   test_truth(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
3933   char* value=memcached_get(memc, keys[0], lengths[0], &length, &flags, &ret);
3934   test_truth(ret == MEMCACHED_SUCCESS && value != NULL);
3935   free(value);
3936
3937   return TEST_SUCCESS;
3938 }
3939
3940 static test_return_t analyzer_test(memcached_st *memc)
3941 {
3942   memcached_return_t rc;
3943   memcached_stat_st *memc_stat;
3944   memcached_analysis_st *report;
3945
3946   memc_stat= memcached_stat(memc, NULL, &rc);
3947   test_truth(rc == MEMCACHED_SUCCESS);
3948   test_truth(memc_stat);
3949
3950   report= memcached_analyze(memc, memc_stat, &rc);
3951   test_truth(rc == MEMCACHED_SUCCESS);
3952   test_truth(report);
3953
3954   free(report);
3955   memcached_stat_free(NULL, memc_stat);
3956
3957   return TEST_SUCCESS;
3958 }
3959
3960 /* Count the objects */
3961 static memcached_return_t callback_dump_counter(memcached_st *ptr __attribute__((unused)),
3962                                               const char *key __attribute__((unused)),
3963                                               size_t key_length __attribute__((unused)),
3964                                               void *context)
3965 {
3966   uint32_t *counter= (uint32_t *)context;
3967
3968   *counter= *counter + 1;
3969
3970   return MEMCACHED_SUCCESS;
3971 }
3972
3973 static test_return_t dump_test(memcached_st *memc)
3974 {
3975   memcached_return_t rc;
3976   uint32_t counter= 0;
3977   memcached_dump_fn callbacks[1];
3978   test_return_t main_rc;
3979
3980   callbacks[0]= &callback_dump_counter;
3981
3982   /* No support for Binary protocol yet */
3983   if (memc->flags.binary_protocol)
3984     return TEST_SUCCESS;
3985
3986   main_rc= set_test3(memc);
3987
3988   test_truth (main_rc == TEST_SUCCESS);
3989
3990   rc= memcached_dump(memc, callbacks, (void *)&counter, 1);
3991   test_truth(rc == MEMCACHED_SUCCESS);
3992
3993   /* We may have more then 32 if our previous flush has not completed */
3994   test_truth(counter >= 32);
3995
3996   return TEST_SUCCESS;
3997 }
3998
3999 #ifdef HAVE_LIBMEMCACHEDUTIL
4000 static void* connection_release(void *arg)
4001 {
4002   struct {
4003     memcached_pool_st* pool;
4004     memcached_st* mmc;
4005   } *resource= arg;
4006
4007   usleep(250);
4008   assert(memcached_pool_push(resource->pool, resource->mmc) == MEMCACHED_SUCCESS);
4009   return arg;
4010 }
4011
4012 static test_return_t connection_pool_test(memcached_st *memc)
4013 {
4014   memcached_pool_st* pool= memcached_pool_create(memc, 5, 10);
4015   test_truth(pool != NULL);
4016   memcached_st* mmc[10];
4017   memcached_return_t rc;
4018
4019   for (int x= 0; x < 10; ++x) {
4020     mmc[x]= memcached_pool_pop(pool, false, &rc);
4021     test_truth(mmc[x] != NULL);
4022     test_truth(rc == MEMCACHED_SUCCESS);
4023   }
4024
4025   test_truth(memcached_pool_pop(pool, false, &rc) == NULL);
4026   test_truth(rc == MEMCACHED_SUCCESS);
4027
4028   pthread_t tid;
4029   struct {
4030     memcached_pool_st* pool;
4031     memcached_st* mmc;
4032   } item= { .pool = pool, .mmc = mmc[9] };
4033   pthread_create(&tid, NULL, connection_release, &item);
4034   mmc[9]= memcached_pool_pop(pool, true, &rc);
4035   test_truth(rc == MEMCACHED_SUCCESS);
4036   pthread_join(tid, NULL);
4037   test_truth(mmc[9] == item.mmc);
4038   const char *key= "key";
4039   size_t keylen= strlen(key);
4040
4041   // verify that I can do ops with all connections
4042   rc= memcached_set(mmc[0], key, keylen, "0", 1, 0, 0);
4043   test_truth(rc == MEMCACHED_SUCCESS);
4044
4045   for (unsigned int x= 0; x < 10; ++x) {
4046     uint64_t number_value;
4047     rc= memcached_increment(mmc[x], key, keylen, 1, &number_value);
4048     test_truth(rc == MEMCACHED_SUCCESS);
4049     test_truth(number_value == (x+1));
4050   }
4051
4052   // Release them..
4053   for (int x= 0; x < 10; ++x)
4054     test_truth(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS);
4055
4056
4057   /* verify that I can set behaviors on the pool when I don't have all
4058    * of the connections in the pool. It should however be enabled
4059    * when I push the item into the pool
4060    */
4061   mmc[0]= memcached_pool_pop(pool, false, &rc);
4062   test_truth(mmc[0] != NULL);
4063
4064   rc= memcached_pool_behavior_set(pool, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 9999);
4065   test_truth(rc == MEMCACHED_SUCCESS);
4066
4067   mmc[1]= memcached_pool_pop(pool, false, &rc);
4068   test_truth(mmc[1] != NULL);
4069
4070   test_truth(memcached_behavior_get(mmc[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
4071   test_truth(memcached_pool_push(pool, mmc[1]) == MEMCACHED_SUCCESS);
4072   test_truth(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
4073
4074   mmc[0]= memcached_pool_pop(pool, false, &rc);
4075   test_truth(memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
4076   test_truth(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
4077
4078
4079   test_truth(memcached_pool_destroy(pool) == memc);
4080   return TEST_SUCCESS;
4081 }
4082 #endif
4083
4084 static test_return_t replication_set_test(memcached_st *memc)
4085 {
4086   memcached_return_t rc;
4087   memcached_st *memc_clone= memcached_clone(NULL, memc);
4088   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
4089
4090   rc= memcached_set(memc, "bubba", 5, "0", 1, 0, 0);
4091   test_truth(rc == MEMCACHED_SUCCESS);
4092
4093   /*
4094   ** We are using the quiet commands to store the replicas, so we need
4095   ** to ensure that all of them are processed before we can continue.
4096   ** In the test we go directly from storing the object to trying to
4097   ** receive the object from all of the different servers, so we
4098   ** could end up in a race condition (the memcached server hasn't yet
4099   ** processed the quiet command from the replication set when it process
4100   ** the request from the other client (created by the clone)). As a
4101   ** workaround for that we call memcached_quit to send the quit command
4102   ** to the server and wait for the response ;-) If you use the test code
4103   ** as an example for your own code, please note that you shouldn't need
4104   ** to do this ;-)
4105   */
4106   memcached_quit(memc);
4107
4108   /*
4109   ** "bubba" should now be stored on all of our servers. We don't have an
4110   ** easy to use API to address each individual server, so I'll just iterate
4111   ** through a bunch of "master keys" and I should most likely hit all of the
4112   ** servers...
4113   */
4114   for (int x= 'a'; x <= 'z'; ++x)
4115   {
4116     char key[2]= { [0]= (char)x };
4117     size_t len;
4118     uint32_t flags;
4119     char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
4120                                     &len, &flags, &rc);
4121     test_truth(rc == MEMCACHED_SUCCESS);
4122     test_truth(val != NULL);
4123     free(val);
4124   }
4125
4126   memcached_free(memc_clone);
4127
4128   return TEST_SUCCESS;
4129 }
4130
4131 static test_return_t replication_get_test(memcached_st *memc)
4132 {
4133   memcached_return_t rc;
4134
4135   /*
4136    * Don't do the following in your code. I am abusing the internal details
4137    * within the library, and this is not a supported interface.
4138    * This is to verify correct behavior in the library
4139    */
4140   for (uint32_t host= 0; host < memc->number_of_hosts; ++host)
4141   {
4142     memcached_st *memc_clone= memcached_clone(NULL, memc);
4143     memc_clone->hosts[host].port= 0;
4144
4145     for (int x= 'a'; x <= 'z'; ++x)
4146     {
4147       char key[2]= { [0]= (char)x };
4148       size_t len;
4149       uint32_t flags;
4150       char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
4151                                       &len, &flags, &rc);
4152       test_truth(rc == MEMCACHED_SUCCESS);
4153       test_truth(val != NULL);
4154       free(val);
4155     }
4156
4157     memcached_free(memc_clone);
4158   }
4159
4160   return TEST_SUCCESS;
4161 }
4162
4163 static test_return_t replication_mget_test(memcached_st *memc)
4164 {
4165   memcached_return_t rc;
4166   memcached_st *memc_clone= memcached_clone(NULL, memc);
4167   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
4168
4169   const char *keys[]= { "bubba", "key1", "key2", "key3" };
4170   size_t len[]= { 5, 4, 4, 4 };
4171
4172   for (int x=0; x< 4; ++x)
4173   {
4174     rc= memcached_set(memc, keys[x], len[x], "0", 1, 0, 0);
4175     test_truth(rc == MEMCACHED_SUCCESS);
4176   }
4177
4178   /*
4179   ** We are using the quiet commands to store the replicas, so we need
4180   ** to ensure that all of them are processed before we can continue.
4181   ** In the test we go directly from storing the object to trying to
4182   ** receive the object from all of the different servers, so we
4183   ** could end up in a race condition (the memcached server hasn't yet
4184   ** processed the quiet command from the replication set when it process
4185   ** the request from the other client (created by the clone)). As a
4186   ** workaround for that we call memcached_quit to send the quit command
4187   ** to the server and wait for the response ;-) If you use the test code
4188   ** as an example for your own code, please note that you shouldn't need
4189   ** to do this ;-)
4190   */
4191   memcached_quit(memc);
4192
4193   /*
4194    * Don't do the following in your code. I am abusing the internal details
4195    * within the library, and this is not a supported interface.
4196    * This is to verify correct behavior in the library
4197    */
4198   memcached_result_st result_obj;
4199   for (uint32_t host= 0; host < memc_clone->number_of_hosts; host++)
4200   {
4201     memcached_st *new_clone= memcached_clone(NULL, memc);
4202     new_clone->hosts[host].port= 0;
4203
4204     for (int x= 'a'; x <= 'z'; ++x)
4205     {
4206       const char key[2]= { [0]= (const char)x };
4207
4208       rc= memcached_mget_by_key(new_clone, key, 1, keys, len, 4);
4209       test_truth(rc == MEMCACHED_SUCCESS);
4210
4211       memcached_result_st *results= memcached_result_create(new_clone, &result_obj);
4212       test_truth(results);
4213
4214       int hits= 0;
4215       while ((results= memcached_fetch_result(new_clone, &result_obj, &rc)) != NULL)
4216       {
4217         hits++;
4218       }
4219       test_truth(hits == 4);
4220       memcached_result_free(&result_obj);
4221     }
4222
4223     memcached_free(new_clone);
4224   }
4225
4226   memcached_free(memc_clone);
4227
4228   return TEST_SUCCESS;
4229 }
4230
4231 static test_return_t replication_randomize_mget_test(memcached_st *memc)
4232 {
4233   memcached_result_st result_obj;
4234   memcached_return_t rc;
4235   memcached_st *memc_clone= memcached_clone(NULL, memc);
4236   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 3);
4237   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ, 1);
4238
4239   const char *keys[]= { "key1", "key2", "key3", "key4", "key5", "key6", "key7" };
4240   size_t len[]= { 4, 4, 4, 4, 4, 4, 4 };
4241
4242   for (int x=0; x< 7; ++x)
4243   {
4244     rc= memcached_set(memc, keys[x], len[x], "1", 1, 0, 0);
4245     test_truth(rc == MEMCACHED_SUCCESS);
4246   }
4247
4248   memcached_quit(memc);
4249
4250   for (int x=0; x< 7; ++x) {
4251     const char key[2]= { [0]= (const char)x };
4252
4253     rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 7);
4254     test_truth(rc == MEMCACHED_SUCCESS);
4255
4256     memcached_result_st *results= memcached_result_create(memc_clone, &result_obj);
4257     test_truth(results);
4258
4259     int hits= 0;
4260     while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL)
4261     {
4262       ++hits;
4263     }
4264     test_truth(hits == 7);
4265     memcached_result_free(&result_obj);
4266   }
4267   memcached_free(memc_clone);
4268   return TEST_SUCCESS;
4269 }
4270
4271 static test_return_t replication_delete_test(memcached_st *memc)
4272 {
4273   memcached_return_t rc;
4274   memcached_st *memc_clone= memcached_clone(NULL, memc);
4275   /* Delete the items from all of the servers except 1 */
4276   uint64_t repl= memcached_behavior_get(memc,
4277                                         MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
4278   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, --repl);
4279
4280   const char *keys[]= { "bubba", "key1", "key2", "key3" };
4281   size_t len[]= { 5, 4, 4, 4 };
4282
4283   for (int x=0; x< 4; ++x)
4284   {
4285     rc= memcached_delete_by_key(memc, keys[0], len[0], keys[x], len[x], 0);
4286     test_truth(rc == MEMCACHED_SUCCESS);
4287   }
4288
4289   /*
4290    * Don't do the following in your code. I am abusing the internal details
4291    * within the library, and this is not a supported interface.
4292    * This is to verify correct behavior in the library
4293    */
4294   uint32_t hash= memcached_generate_hash(memc, keys[0], len[0]);
4295   for (uint32_t x= 0; x < (repl + 1); ++x)
4296   {
4297     memc_clone->hosts[hash].port= 0;
4298     if (++hash == memc_clone->number_of_hosts)
4299       hash= 0;
4300   }
4301
4302   memcached_result_st result_obj;
4303   for (uint32_t host= 0; host < memc_clone->number_of_hosts; ++host)
4304   {
4305     for (int x= 'a'; x <= 'z'; ++x)
4306     {
4307       const char key[2]= { [0]= (const char)x };
4308
4309       rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 4);
4310       test_truth(rc == MEMCACHED_SUCCESS);
4311
4312       memcached_result_st *results= memcached_result_create(memc_clone, &result_obj);
4313       test_truth(results);
4314
4315       int hits= 0;
4316       while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL)
4317       {
4318         ++hits;
4319       }
4320       test_truth(hits == 4);
4321       memcached_result_free(&result_obj);
4322     }
4323   }
4324   memcached_free(memc_clone);
4325
4326   return TEST_SUCCESS;
4327 }
4328
4329 static void increment_request_id(uint16_t *id)
4330 {
4331   (*id)++;
4332   if ((*id & UDP_REQUEST_ID_THREAD_MASK) != 0)
4333     *id= 0;
4334 }
4335
4336 static uint16_t *get_udp_request_ids(memcached_st *memc)
4337 {
4338   uint16_t *ids= malloc(sizeof(uint16_t) * memc->number_of_hosts);
4339   assert(ids != NULL);
4340   unsigned int x;
4341
4342   for (x= 0; x < memc->number_of_hosts; x++)
4343     ids[x]= get_udp_datagram_request_id((struct udp_datagram_header_st *) memc->hosts[x].write_buffer);
4344
4345   return ids;
4346 }
4347
4348 static test_return_t post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ids)
4349 {
4350   unsigned int x;
4351   memcached_server_st *cur_server = memc->hosts;
4352   uint16_t *cur_req_ids = get_udp_request_ids(memc);
4353
4354   for (x= 0; x < memc->number_of_hosts; x++)
4355   {
4356     test_truth(cur_server[x].cursor_active == 0);
4357     test_truth(cur_req_ids[x] == expected_req_ids[x]);
4358   }
4359   free(expected_req_ids);
4360   free(cur_req_ids);
4361
4362   return TEST_SUCCESS;
4363 }
4364
4365 /*
4366 ** There is a little bit of a hack here, instead of removing
4367 ** the servers, I just set num host to 0 and them add then new udp servers
4368 **/
4369 static test_return_t init_udp(memcached_st *memc)
4370 {
4371   memcached_version(memc);
4372   /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
4373   if (memc->hosts[0].major_version != 1 || memc->hosts[0].minor_version != 2
4374           || memc->hosts[0].micro_version < 6)
4375     return TEST_SKIPPED;
4376
4377   uint32_t num_hosts= memc->number_of_hosts;
4378   unsigned int x= 0;
4379   memcached_server_st servers[num_hosts];
4380   memcpy(servers, memc->hosts, sizeof(memcached_server_st) * num_hosts);
4381   for (x= 0; x < num_hosts; x++)
4382     memcached_server_free(&memc->hosts[x]);
4383
4384   memc->number_of_hosts= 0;
4385   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1);
4386   for (x= 0; x < num_hosts; x++)
4387   {
4388     test_truth(memcached_server_add_udp(memc, servers[x].hostname, servers[x].port) == MEMCACHED_SUCCESS);
4389     test_truth(memc->hosts[x].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
4390   }
4391
4392   return TEST_SUCCESS;
4393 }
4394
4395 static test_return_t binary_init_udp(memcached_st *memc)
4396 {
4397   pre_binary(memc);
4398   return init_udp(memc);
4399 }
4400
4401 /* Make sure that I cant add a tcp server to a udp client */
4402 static test_return_t add_tcp_server_udp_client_test(memcached_st *memc)
4403 {
4404   memcached_server_st server;
4405   memcached_server_clone(&server, &memc->hosts[0]);
4406   test_truth(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
4407   test_truth(memcached_server_add(memc, server.hostname, server.port) == MEMCACHED_INVALID_HOST_PROTOCOL);
4408   return TEST_SUCCESS;
4409 }
4410
4411 /* Make sure that I cant add a udp server to a tcp client */
4412 static test_return_t add_udp_server_tcp_client_test(memcached_st *memc)
4413 {
4414   memcached_server_st server;
4415   memcached_server_clone(&server, &memc->hosts[0]);
4416   test_truth(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
4417
4418   memcached_st tcp_client;
4419   memcached_create(&tcp_client);
4420   test_truth(memcached_server_add_udp(&tcp_client, server.hostname, server.port) == MEMCACHED_INVALID_HOST_PROTOCOL);
4421
4422   return TEST_SUCCESS;
4423 }
4424
4425 static test_return_t set_udp_behavior_test(memcached_st *memc)
4426 {
4427
4428   memcached_quit(memc);
4429   memc->number_of_hosts= 0;
4430   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, memc->distribution);
4431   test_truth(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1) == MEMCACHED_SUCCESS);
4432   test_truth(memc->flags.use_udp);
4433   test_truth(memc->flags.no_reply);
4434
4435   test_truth(memc->number_of_hosts == 0);
4436
4437   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP,0);
4438   test_truth(! (memc->flags.use_udp));
4439   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY,0);
4440   test_truth(! (memc->flags.no_reply));
4441
4442   return TEST_SUCCESS;
4443 }
4444
4445 static test_return_t udp_set_test(memcached_st *memc)
4446 {
4447   unsigned int x= 0;
4448   unsigned int num_iters= 1025; //request id rolls over at 1024
4449   for (x= 0; x < num_iters;x++)
4450   {
4451     memcached_return_t rc;
4452     const char *key= "foo";
4453     const char *value= "when we sanitize";
4454     uint16_t *expected_ids= get_udp_request_ids(memc);
4455     unsigned int server_key= memcached_generate_hash(memc,key,strlen(key));
4456     size_t init_offset= memc->hosts[server_key].write_buffer_offset;
4457     rc= memcached_set(memc, key, strlen(key),
4458                       value, strlen(value),
4459                       (time_t)0, (uint32_t)0);
4460     test_truth(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
4461     /** NB, the check below assumes that if new write_ptr is less than
4462      *  the original write_ptr that we have flushed. For large payloads, this
4463      *  maybe an invalid assumption, but for the small payload we have it is OK
4464      */
4465     if (rc == MEMCACHED_SUCCESS ||
4466             memc->hosts[server_key].write_buffer_offset < init_offset)
4467       increment_request_id(&expected_ids[server_key]);
4468
4469     if (rc == MEMCACHED_SUCCESS)
4470     {
4471       test_truth(memc->hosts[server_key].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
4472     }
4473     else
4474     {
4475       test_truth(memc->hosts[server_key].write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
4476       test_truth(memc->hosts[server_key].write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
4477     }
4478     test_truth(post_udp_op_check(memc,expected_ids) == TEST_SUCCESS);
4479   }
4480   return TEST_SUCCESS;
4481 }
4482
4483 static test_return_t udp_buffered_set_test(memcached_st *memc)
4484 {
4485   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
4486   return udp_set_test(memc);
4487 }
4488
4489 static test_return_t udp_set_too_big_test(memcached_st *memc)
4490 {
4491   memcached_return_t rc;
4492   const char *key= "bar";
4493   char value[MAX_UDP_DATAGRAM_LENGTH];
4494   uint16_t *expected_ids= get_udp_request_ids(memc);
4495   rc= memcached_set(memc, key, strlen(key),
4496                     value, MAX_UDP_DATAGRAM_LENGTH,
4497                     (time_t)0, (uint32_t)0);
4498   test_truth(rc == MEMCACHED_WRITE_FAILURE);
4499   return post_udp_op_check(memc,expected_ids);
4500 }
4501
4502 static test_return_t udp_delete_test(memcached_st *memc)
4503 {
4504   unsigned int x= 0;
4505   unsigned int num_iters= 1025; //request id rolls over at 1024
4506   for (x= 0; x < num_iters;x++)
4507   {
4508     memcached_return_t rc;
4509     const char *key= "foo";
4510     uint16_t *expected_ids=get_udp_request_ids(memc);
4511     unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
4512     size_t init_offset= memc->hosts[server_key].write_buffer_offset;
4513     rc= memcached_delete(memc, key, strlen(key), 0);
4514     test_truth(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
4515     if (rc == MEMCACHED_SUCCESS || memc->hosts[server_key].write_buffer_offset < init_offset)
4516       increment_request_id(&expected_ids[server_key]);
4517     if (rc == MEMCACHED_SUCCESS)
4518     {
4519       test_truth(memc->hosts[server_key].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
4520     }
4521     else
4522     {
4523       test_truth(memc->hosts[server_key].write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
4524       test_truth(memc->hosts[server_key].write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
4525     }
4526     test_truth(post_udp_op_check(memc,expected_ids) == TEST_SUCCESS);
4527   }
4528   return TEST_SUCCESS;
4529 }
4530
4531 static test_return_t udp_buffered_delete_test(memcached_st *memc)
4532 {
4533   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
4534   return udp_delete_test(memc);
4535 }
4536
4537 static test_return_t udp_verbosity_test(memcached_st *memc)
4538 {
4539   memcached_return_t rc;
4540   uint16_t *expected_ids= get_udp_request_ids(memc);
4541   unsigned int x;
4542   for (x= 0; x < memc->number_of_hosts;x++)
4543     increment_request_id(&expected_ids[x]);
4544
4545   rc= memcached_verbosity(memc,3);
4546   test_truth(rc == MEMCACHED_SUCCESS);
4547   return post_udp_op_check(memc,expected_ids);
4548 }
4549
4550 static test_return_t udp_quit_test(memcached_st *memc)
4551 {
4552   uint16_t *expected_ids= get_udp_request_ids(memc);
4553   memcached_quit(memc);
4554   return post_udp_op_check(memc, expected_ids);
4555 }
4556
4557 static test_return_t udp_flush_test(memcached_st *memc)
4558 {
4559   memcached_return_t rc;
4560   uint16_t *expected_ids= get_udp_request_ids(memc);
4561   unsigned int x;
4562   for (x= 0; x < memc->number_of_hosts;x++)
4563     increment_request_id(&expected_ids[x]);
4564
4565   rc= memcached_flush(memc,0);
4566   test_truth(rc == MEMCACHED_SUCCESS);
4567   return post_udp_op_check(memc,expected_ids);
4568 }
4569
4570 static test_return_t udp_incr_test(memcached_st *memc)
4571 {
4572   memcached_return_t rc;
4573   const char *key= "incr";
4574   const char *value= "1";
4575   rc= memcached_set(memc, key, strlen(key),
4576                     value, strlen(value),
4577                     (time_t)0, (uint32_t)0);
4578
4579   test_truth(rc == MEMCACHED_SUCCESS);
4580   uint16_t *expected_ids= get_udp_request_ids(memc);
4581   unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
4582   increment_request_id(&expected_ids[server_key]);
4583   uint64_t newvalue;
4584   rc= memcached_increment(memc, key, strlen(key), 1, &newvalue);
4585   test_truth(rc == MEMCACHED_SUCCESS);
4586   return post_udp_op_check(memc, expected_ids);
4587 }
4588
4589 static test_return_t udp_decr_test(memcached_st *memc)
4590 {
4591   memcached_return_t rc;
4592   const char *key= "decr";
4593   const char *value= "1";
4594   rc= memcached_set(memc, key, strlen(key),
4595                     value, strlen(value),
4596                     (time_t)0, (uint32_t)0);
4597
4598   test_truth(rc == MEMCACHED_SUCCESS);
4599   uint16_t *expected_ids= get_udp_request_ids(memc);
4600   unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
4601   increment_request_id(&expected_ids[server_key]);
4602   uint64_t newvalue;
4603   rc= memcached_decrement(memc, key, strlen(key), 1, &newvalue);
4604   test_truth(rc == MEMCACHED_SUCCESS);
4605   return post_udp_op_check(memc, expected_ids);
4606 }
4607
4608
4609 static test_return_t udp_stat_test(memcached_st *memc)
4610 {
4611   memcached_stat_st * rv= NULL;
4612   memcached_return_t rc;
4613   char args[]= "";
4614   uint16_t *expected_ids = get_udp_request_ids(memc);
4615   rv = memcached_stat(memc, args, &rc);
4616   free(rv);
4617   test_truth(rc == MEMCACHED_NOT_SUPPORTED);
4618   return post_udp_op_check(memc, expected_ids);
4619 }
4620
4621 static test_return_t udp_version_test(memcached_st *memc)
4622 {
4623   memcached_return_t rc;
4624   uint16_t *expected_ids = get_udp_request_ids(memc);
4625   rc = memcached_version(memc);
4626   test_truth(rc == MEMCACHED_NOT_SUPPORTED);
4627   return post_udp_op_check(memc, expected_ids);
4628 }
4629
4630 static test_return_t udp_get_test(memcached_st *memc)
4631 {
4632   memcached_return_t rc;
4633   const char *key= "foo";
4634   size_t vlen;
4635   uint16_t *expected_ids = get_udp_request_ids(memc);
4636   char *val= memcached_get(memc, key, strlen(key), &vlen, (uint32_t)0, &rc);
4637   test_truth(rc == MEMCACHED_NOT_SUPPORTED);
4638   test_truth(val == NULL);
4639   return post_udp_op_check(memc, expected_ids);
4640 }
4641
4642 static test_return_t udp_mixed_io_test(memcached_st *memc)
4643 {
4644   test_st current_op;
4645   test_st mixed_io_ops [] ={
4646     {"udp_set_test", 0,
4647       (test_callback_fn)udp_set_test},
4648     {"udp_set_too_big_test", 0,
4649       (test_callback_fn)udp_set_too_big_test},
4650     {"udp_delete_test", 0,
4651       (test_callback_fn)udp_delete_test},
4652     {"udp_verbosity_test", 0,
4653       (test_callback_fn)udp_verbosity_test},
4654     {"udp_quit_test", 0,
4655       (test_callback_fn)udp_quit_test},
4656     {"udp_flush_test", 0,
4657       (test_callback_fn)udp_flush_test},
4658     {"udp_incr_test", 0,
4659       (test_callback_fn)udp_incr_test},
4660     {"udp_decr_test", 0,
4661       (test_callback_fn)udp_decr_test},
4662     {"udp_version_test", 0,
4663       (test_callback_fn)udp_version_test}
4664   };
4665   unsigned int x= 0;
4666   for (x= 0; x < 500; x++)
4667   {
4668     current_op= mixed_io_ops[random() % 9];
4669     test_truth(current_op.test_fn(memc) == TEST_SUCCESS);
4670   }
4671   return TEST_SUCCESS;
4672 }
4673
4674 #if 0
4675 static test_return_t hash_sanity_test (memcached_st *memc)
4676 {
4677   (void)memc;
4678
4679   assert(MEMCACHED_HASH_DEFAULT == MEMCACHED_HASH_DEFAULT);
4680   assert(MEMCACHED_HASH_MD5 == MEMCACHED_HASH_MD5);
4681   assert(MEMCACHED_HASH_CRC == MEMCACHED_HASH_CRC);
4682   assert(MEMCACHED_HASH_FNV1_64 == MEMCACHED_HASH_FNV1_64);
4683   assert(MEMCACHED_HASH_FNV1A_64 == MEMCACHED_HASH_FNV1A_64);
4684   assert(MEMCACHED_HASH_FNV1_32 == MEMCACHED_HASH_FNV1_32);
4685   assert(MEMCACHED_HASH_FNV1A_32 == MEMCACHED_HASH_FNV1A_32);
4686 #ifdef HAVE_HSIEH_HASH
4687   assert(MEMCACHED_HASH_HSIEH == MEMCACHED_HASH_HSIEH);
4688 #endif
4689   assert(MEMCACHED_HASH_MURMUR == MEMCACHED_HASH_MURMUR);
4690   assert(MEMCACHED_HASH_JENKINS == MEMCACHED_HASH_JENKINS);
4691   assert(MEMCACHED_HASH_MAX == MEMCACHED_HASH_MAX);
4692
4693   return TEST_SUCCESS;
4694 }
4695 #endif
4696
4697 static test_return_t hsieh_avaibility_test (memcached_st *memc)
4698 {
4699   memcached_return_t expected_rc= MEMCACHED_FAILURE;
4700 #ifdef HAVE_HSIEH_HASH
4701   expected_rc= MEMCACHED_SUCCESS;
4702 #endif
4703   memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
4704                                             (uint64_t)MEMCACHED_HASH_HSIEH);
4705   test_truth(rc == expected_rc);
4706   return TEST_SUCCESS;
4707 }
4708
4709 static test_return_t md5_run (memcached_st *memc __attribute__((unused)))
4710 {
4711   uint32_t x;
4712   const char **ptr;
4713
4714   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4715   {
4716     uint32_t hash_val;
4717
4718     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5);
4719     test_truth(md5_values[x] == hash_val);
4720   }
4721
4722   return TEST_SUCCESS;
4723 }
4724
4725 static test_return_t crc_run (memcached_st *memc __attribute__((unused)))
4726 {
4727   uint32_t x;
4728   const char **ptr;
4729
4730   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4731   {
4732     uint32_t hash_val;
4733
4734     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC);
4735     test_truth(crc_values[x] == hash_val);
4736   }
4737
4738   return TEST_SUCCESS;
4739 }
4740
4741 static test_return_t fnv1_64_run (memcached_st *memc __attribute__((unused)))
4742 {
4743   uint32_t x;
4744   const char **ptr;
4745
4746   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4747   {
4748     uint32_t hash_val;
4749
4750     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
4751     test_truth(fnv1_64_values[x] == hash_val);
4752   }
4753
4754   return TEST_SUCCESS;
4755 }
4756
4757 static test_return_t fnv1a_64_run (memcached_st *memc __attribute__((unused)))
4758 {
4759   uint32_t x;
4760   const char **ptr;
4761
4762   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4763   {
4764     uint32_t hash_val;
4765
4766     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64);
4767     test_truth(fnv1a_64_values[x] == hash_val);
4768   }
4769
4770   return TEST_SUCCESS;
4771 }
4772
4773 static test_return_t fnv1_32_run (memcached_st *memc __attribute__((unused)))
4774 {
4775   uint32_t x;
4776   const char **ptr;
4777
4778
4779   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4780   {
4781     uint32_t hash_val;
4782
4783     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32);
4784     test_truth(fnv1_32_values[x] == hash_val);
4785   }
4786
4787   return TEST_SUCCESS;
4788 }
4789
4790 static test_return_t fnv1a_32_run (memcached_st *memc __attribute__((unused)))
4791 {
4792   uint32_t x;
4793   const char **ptr;
4794
4795   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4796   {
4797     uint32_t hash_val;
4798
4799     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32);
4800     test_truth(fnv1a_32_values[x] == hash_val);
4801   }
4802
4803   return TEST_SUCCESS;
4804 }
4805
4806 static test_return_t hsieh_run (memcached_st *memc __attribute__((unused)))
4807 {
4808   uint32_t x;
4809   const char **ptr;
4810
4811   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4812   {
4813     uint32_t hash_val;
4814
4815     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH);
4816     test_truth(hsieh_values[x] == hash_val);
4817   }
4818
4819   return TEST_SUCCESS;
4820 }
4821
4822 static test_return_t murmur_run (memcached_st *memc __attribute__((unused)))
4823 {
4824 #ifdef __sparc
4825   return TEST_SKIPPED;
4826 #else
4827   uint32_t x;
4828   const char **ptr;
4829
4830   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4831   {
4832     uint32_t hash_val;
4833
4834     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR);
4835     test_truth(murmur_values[x] == hash_val);
4836   }
4837
4838   return TEST_SUCCESS;
4839 #endif
4840 }
4841
4842 static test_return_t jenkins_run (memcached_st *memc __attribute__((unused)))
4843 {
4844   uint32_t x;
4845   const char **ptr;
4846
4847
4848   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4849   {
4850     uint32_t hash_val;
4851
4852     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS);
4853     test_truth(jenkins_values[x] == hash_val);
4854   }
4855
4856   return TEST_SUCCESS;
4857 }
4858
4859
4860 static test_return_t ketama_compatibility_libmemcached(memcached_st *trash)
4861 {
4862   memcached_return_t rc;
4863   uint64_t value;
4864   int x;
4865   memcached_server_st *server_pool;
4866   memcached_st *memc;
4867
4868   (void)trash;
4869
4870   memc= memcached_create(NULL);
4871   test_truth(memc);
4872
4873   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
4874   test_truth(rc == MEMCACHED_SUCCESS);
4875
4876   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
4877   test_truth(value == 1);
4878
4879   test_truth(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) == MEMCACHED_SUCCESS);
4880   test_truth(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
4881
4882
4883   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");
4884   memcached_server_push(memc, server_pool);
4885
4886   /* verify that the server list was parsed okay. */
4887   assert(memc->number_of_hosts == 8);
4888   assert(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
4889   assert(server_pool[0].port == 11211);
4890   assert(server_pool[0].weight == 600);
4891   assert(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
4892   assert(server_pool[2].port == 11211);
4893   assert(server_pool[2].weight == 200);
4894   assert(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
4895   assert(server_pool[7].port == 11211);
4896   assert(server_pool[7].weight == 100);
4897
4898   /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
4899    * us test the boundary wraparound.
4900    */
4901   assert(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
4902
4903   /* verify the standard ketama set. */
4904   for (x= 0; x < 99; x++)
4905   {
4906     uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
4907     char *hostname = memc->hosts[server_idx].hostname;
4908     assert(strcmp(hostname, ketama_test_cases[x].server) == 0);
4909   }
4910
4911   memcached_server_list_free(server_pool);
4912   memcached_free(memc);
4913
4914   return TEST_SUCCESS;
4915 }
4916
4917 static test_return_t ketama_compatibility_spymemcached(memcached_st *trash)
4918 {
4919   memcached_return_t rc;
4920   uint64_t value;
4921   int x;
4922   memcached_server_st *server_pool;
4923   memcached_st *memc;
4924
4925   (void)trash;
4926
4927   memc= memcached_create(NULL);
4928   test_truth(memc);
4929
4930   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
4931   test_truth(rc == MEMCACHED_SUCCESS);
4932
4933   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
4934   test_truth(value == 1);
4935
4936   test_truth(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);
4937   test_truth(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY);
4938
4939   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");
4940   memcached_server_push(memc, server_pool);
4941
4942   /* verify that the server list was parsed okay. */
4943   assert(memc->number_of_hosts == 8);
4944   assert(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
4945   assert(server_pool[0].port == 11211);
4946   assert(server_pool[0].weight == 600);
4947   assert(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
4948   assert(server_pool[2].port == 11211);
4949   assert(server_pool[2].weight == 200);
4950   assert(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
4951   assert(server_pool[7].port == 11211);
4952   assert(server_pool[7].weight == 100);
4953
4954   /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
4955    * us test the boundary wraparound.
4956    */
4957   assert(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
4958
4959   /* verify the standard ketama set. */
4960   for (x= 0; x < 99; x++)
4961   {
4962     uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases_spy[x].key, strlen(ketama_test_cases_spy[x].key));
4963     char *hostname = memc->hosts[server_idx].hostname;
4964     assert(strcmp(hostname, ketama_test_cases_spy[x].server) == 0);
4965   }
4966
4967   memcached_server_list_free(server_pool);
4968   memcached_free(memc);
4969
4970   return TEST_SUCCESS;
4971 }
4972
4973 static test_return_t regression_bug_434484(memcached_st *memc)
4974 {
4975   if (pre_binary(memc) != MEMCACHED_SUCCESS)
4976     return TEST_SKIPPED;
4977
4978   memcached_return_t ret;
4979   const char *key= "regression_bug_434484";
4980   size_t keylen= strlen(key);
4981
4982   ret= memcached_append(memc, key, keylen, key, keylen, 0, 0);
4983   assert(ret == MEMCACHED_NOTSTORED);
4984
4985   size_t size= 2048 * 1024;
4986   void *data= calloc(1, size);
4987   assert(data != NULL);
4988   ret= memcached_set(memc, key, keylen, data, size, 0, 0);
4989   assert(ret == MEMCACHED_E2BIG);
4990   free(data);
4991
4992   return TEST_SUCCESS;
4993 }
4994
4995 static test_return_t regression_bug_434843(memcached_st *memc)
4996 {
4997   if (pre_binary(memc) != MEMCACHED_SUCCESS)
4998     return TEST_SKIPPED;
4999
5000   memcached_return_t rc;
5001   unsigned int counter= 0;
5002   memcached_execute_fn callbacks[1]= { [0]= &callback_counter };
5003
5004   /*
5005    * I only want to hit only _one_ server so I know the number of requests I'm
5006    * sending in the pipleine to the server. Let's try to do a multiget of
5007    * 1024 (that should satisfy most users don't you think?). Future versions
5008    * will include a mget_execute function call if you need a higher number.
5009    */
5010   uint32_t number_of_hosts= memc->number_of_hosts;
5011   memc->number_of_hosts= 1;
5012   const size_t max_keys= 1024;
5013   char **keys= calloc(max_keys, sizeof(char*));
5014   size_t *key_length=calloc(max_keys, sizeof(size_t));
5015
5016   for (int x= 0; x < (int)max_keys; ++x)
5017   {
5018      char k[251];
5019      key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%u", x);
5020      keys[x]= strdup(k);
5021      assert(keys[x] != NULL);
5022   }
5023
5024   /*
5025    * Run two times.. the first time we should have 100% cache miss,
5026    * and the second time we should have 100% cache hits
5027    */
5028   for (int y= 0; y < 2; ++y)
5029   {
5030     rc= memcached_mget(memc, (const char**)keys, key_length, max_keys);
5031     assert(rc == MEMCACHED_SUCCESS);
5032     rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5033     if (y == 0)
5034     {
5035       /* The first iteration should give me a 100% cache miss. verify that*/
5036       assert(counter == 0);
5037       char blob[1024]= { 0 };
5038       for (int x= 0; x < (int)max_keys; ++x)
5039       {
5040         rc= memcached_add(memc, keys[x], key_length[x],
5041                           blob, sizeof(blob), 0, 0);
5042         assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5043       }
5044     }
5045     else
5046     {
5047       /* Verify that we received all of the key/value pairs */
5048        assert(counter == (unsigned int)max_keys);
5049     }
5050   }
5051
5052   /* Release allocated resources */
5053   for (size_t x= 0; x < max_keys; ++x)
5054     free(keys[x]);
5055   free(keys);
5056   free(key_length);
5057
5058   memc->number_of_hosts= number_of_hosts;
5059   return TEST_SUCCESS;
5060 }
5061
5062 static test_return_t regression_bug_434843_buffered(memcached_st *memc)
5063 {
5064   memcached_return_t rc;
5065   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
5066   assert(rc == MEMCACHED_SUCCESS);
5067
5068   return regression_bug_434843(memc);
5069 }
5070
5071 static test_return_t regression_bug_421108(memcached_st *memc)
5072 {
5073   memcached_return_t rc;
5074   memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
5075   assert(rc == MEMCACHED_SUCCESS);
5076
5077   char *bytes= memcached_stat_get_value(memc, memc_stat, "bytes", &rc);
5078   assert(rc == MEMCACHED_SUCCESS);
5079   assert(bytes != NULL);
5080   char *bytes_read= memcached_stat_get_value(memc, memc_stat,
5081                                              "bytes_read", &rc);
5082   assert(rc == MEMCACHED_SUCCESS);
5083   assert(bytes_read != NULL);
5084
5085   char *bytes_written= memcached_stat_get_value(memc, memc_stat,
5086                                                 "bytes_written", &rc);
5087   assert(rc == MEMCACHED_SUCCESS);
5088   assert(bytes_written != NULL);
5089
5090   assert(strcmp(bytes, bytes_read) != 0);
5091   assert(strcmp(bytes, bytes_written) != 0);
5092
5093   /* Release allocated resources */
5094   free(bytes);
5095   free(bytes_read);
5096   free(bytes_written);
5097   memcached_stat_free(NULL, memc_stat);
5098   return TEST_SUCCESS;
5099 }
5100
5101 /*
5102  * The test case isn't obvious so I should probably document why
5103  * it works the way it does. Bug 442914 was caused by a bug
5104  * in the logic in memcached_purge (it did not handle the case
5105  * where the number of bytes sent was equal to the watermark).
5106  * In this test case, create messages so that we hit that case
5107  * and then disable noreply mode and issue a new command to
5108  * verify that it isn't stuck. If we change the format for the
5109  * delete command or the watermarks, we need to update this
5110  * test....
5111  */
5112 static test_return_t regression_bug_442914(memcached_st *memc)
5113 {
5114   memcached_return_t rc;
5115   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
5116   assert(rc == MEMCACHED_SUCCESS);
5117   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
5118
5119   uint32_t number_of_hosts= memc->number_of_hosts;
5120   memc->number_of_hosts= 1;
5121
5122   char k[250];
5123   size_t len;
5124
5125   for (int x= 0; x < 250; ++x)
5126   {
5127      len= (size_t)snprintf(k, sizeof(k), "%0250u", x);
5128      rc= memcached_delete(memc, k, len, 0);
5129      assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5130   }
5131
5132   len= (size_t)snprintf(k, sizeof(k), "%037u", 251);
5133   rc= memcached_delete(memc, k, len, 0);
5134   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5135
5136   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0);
5137   assert(rc == MEMCACHED_SUCCESS);
5138   rc= memcached_delete(memc, k, len, 0);
5139   assert(rc == MEMCACHED_NOTFOUND);
5140
5141   memc->number_of_hosts= number_of_hosts;
5142
5143   return TEST_SUCCESS;
5144 }
5145
5146 static test_return_t regression_bug_447342(memcached_st *memc)
5147 {
5148   if (memc->number_of_hosts < 3 || pre_replication(memc) != MEMCACHED_SUCCESS)
5149     return TEST_SKIPPED;
5150
5151   memcached_return_t rc;
5152
5153   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 2);
5154   assert(rc == MEMCACHED_SUCCESS);
5155
5156   const size_t max_keys= 100;
5157   char **keys= calloc(max_keys, sizeof(char*));
5158   size_t *key_length=calloc(max_keys, sizeof(size_t));
5159
5160   for (int x= 0; x < (int)max_keys; ++x)
5161   {
5162     char k[251];
5163     key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%u", x);
5164     keys[x]= strdup(k);
5165     assert(keys[x] != NULL);
5166     rc= memcached_set(memc, k, key_length[x], k, key_length[x], 0, 0);
5167     assert(rc == MEMCACHED_SUCCESS);
5168   }
5169
5170   /*
5171   ** We are using the quiet commands to store the replicas, so we need
5172   ** to ensure that all of them are processed before we can continue.
5173   ** In the test we go directly from storing the object to trying to
5174   ** receive the object from all of the different servers, so we
5175   ** could end up in a race condition (the memcached server hasn't yet
5176   ** processed the quiet command from the replication set when it process
5177   ** the request from the other client (created by the clone)). As a
5178   ** workaround for that we call memcached_quit to send the quit command
5179   ** to the server and wait for the response ;-) If you use the test code
5180   ** as an example for your own code, please note that you shouldn't need
5181   ** to do this ;-)
5182   */
5183   memcached_quit(memc);
5184
5185   /* Verify that all messages are stored, and we didn't stuff too much
5186    * into the servers
5187    */
5188   rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
5189   assert(rc == MEMCACHED_SUCCESS);
5190
5191   unsigned int counter= 0;
5192   memcached_execute_fn callbacks[1]= { [0]= &callback_counter };
5193   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5194   /* Verify that we received all of the key/value pairs */
5195   assert(counter == (unsigned int)max_keys);
5196
5197   memcached_quit(memc);
5198   /*
5199    * Don't do the following in your code. I am abusing the internal details
5200    * within the library, and this is not a supported interface.
5201    * This is to verify correct behavior in the library. Fake that two servers
5202    * are dead..
5203    */
5204   unsigned int port0= memc->hosts[0].port;
5205   unsigned int port2= memc->hosts[2].port;
5206   memc->hosts[0].port= 0;
5207   memc->hosts[2].port= 0;
5208
5209   rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
5210   assert(rc == MEMCACHED_SUCCESS);
5211
5212   counter= 0;
5213   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5214   assert(counter == (unsigned int)max_keys);
5215
5216   /* restore the memc handle */
5217   memc->hosts[0].port= port0;
5218   memc->hosts[2].port= port2;
5219
5220   memcached_quit(memc);
5221
5222   /* Remove half of the objects */
5223   for (int x= 0; x < (int)max_keys; ++x)
5224     if (x & 1)
5225     {
5226       rc= memcached_delete(memc, keys[x], key_length[x], 0);
5227       assert(rc == MEMCACHED_SUCCESS);
5228     }
5229
5230   memcached_quit(memc);
5231   memc->hosts[0].port= 0;
5232   memc->hosts[2].port= 0;
5233
5234   /* now retry the command, this time we should have cache misses */
5235   rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
5236   assert(rc == MEMCACHED_SUCCESS);
5237
5238   counter= 0;
5239   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5240   assert(counter == (unsigned int)(max_keys >> 1));
5241
5242   /* Release allocated resources */
5243   for (size_t x= 0; x < max_keys; ++x)
5244     free(keys[x]);
5245   free(keys);
5246   free(key_length);
5247
5248   /* restore the memc handle */
5249   memc->hosts[0].port= port0;
5250   memc->hosts[2].port= port2;
5251   return TEST_SUCCESS;
5252 }
5253
5254 static test_return_t regression_bug_463297(memcached_st *memc)
5255 {
5256   memcached_st *memc_clone= memcached_clone(NULL, memc);
5257   assert(memc_clone != NULL);
5258   assert(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
5259
5260   if (memc_clone->hosts[0].major_version > 1 ||
5261       (memc_clone->hosts[0].major_version == 1 &&
5262        memc_clone->hosts[0].minor_version > 2))
5263   {
5264      /* Binary protocol doesn't support deferred delete */
5265      memcached_st *bin_clone= memcached_clone(NULL, memc);
5266      assert(bin_clone != NULL);
5267      assert(memcached_behavior_set(bin_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1) == MEMCACHED_SUCCESS);
5268      assert(memcached_delete(bin_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
5269      memcached_free(bin_clone);
5270
5271      memcached_quit(memc_clone);
5272
5273      /* If we know the server version, deferred delete should fail
5274       * with invalid arguments */
5275      assert(memcached_delete(memc_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
5276
5277      /* If we don't know the server version, we should get a protocol error */
5278      memcached_return_t rc= memcached_delete(memc, "foo", 3, 1);
5279      /* but there is a bug in some of the memcached servers (1.4) that treats
5280       * the counter as noreply so it doesn't send the proper error message
5281       */
5282      assert(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
5283
5284      /* And buffered mode should be disabled and we should get protocol error */
5285      assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS);
5286      rc= memcached_delete(memc, "foo", 3, 1);
5287      assert(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
5288
5289      /* Same goes for noreply... */
5290      assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1) == MEMCACHED_SUCCESS);
5291      rc= memcached_delete(memc, "foo", 3, 1);
5292      assert(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
5293
5294      /* but a normal request should go through (and be buffered) */
5295      assert((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_BUFFERED);
5296      assert(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
5297
5298      assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0) == MEMCACHED_SUCCESS);
5299      /* unbuffered noreply should be success */
5300      assert(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_SUCCESS);
5301      /* unbuffered with reply should be not found... */
5302      assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0) == MEMCACHED_SUCCESS);
5303      assert(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_NOTFOUND);
5304   }
5305
5306   memcached_free(memc_clone);
5307   return TEST_SUCCESS;
5308 }
5309
5310
5311 /* Test memcached_server_get_last_disconnect
5312  * For a working server set, shall be NULL
5313  * For a set of non existing server, shall not be NULL
5314  */
5315 static test_return_t  test_get_last_disconnect(memcached_st *memc)
5316 {
5317   memcached_return_t rc;
5318   memcached_server_st *disconnected_server;
5319
5320   /* With the working set of server */
5321   const char *key= "marmotte";
5322   const char *value= "milka";
5323
5324   rc= memcached_set(memc, key, strlen(key),
5325                     value, strlen(value),
5326                     (time_t)0, (uint32_t)0);
5327   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5328
5329   disconnected_server = memcached_server_get_last_disconnect(memc);
5330   assert(disconnected_server == NULL);
5331
5332   /* With a non existing server */
5333   memcached_st *mine;
5334   memcached_server_st *servers;
5335
5336   const char *server_list= "localhost:9";
5337
5338   servers= memcached_servers_parse(server_list);
5339   assert(servers);
5340   mine= memcached_create(NULL);
5341   rc= memcached_server_push(mine, servers);
5342   assert(rc == MEMCACHED_SUCCESS);
5343   memcached_server_list_free(servers);
5344   assert(mine);
5345
5346   rc= memcached_set(mine, key, strlen(key),
5347                     value, strlen(value),
5348                     (time_t)0, (uint32_t)0);
5349   assert(rc != MEMCACHED_SUCCESS);
5350
5351   disconnected_server = memcached_server_get_last_disconnect(mine);
5352   assert(disconnected_server != NULL);
5353   assert(disconnected_server->port == 9);
5354   assert(strncmp(disconnected_server->hostname,"localhost",9) == 0);
5355
5356   memcached_quit(mine);
5357   memcached_free(mine);
5358
5359   return TEST_SUCCESS;
5360 }
5361
5362 /*
5363  * This test ensures that the failure counter isn't incremented during
5364  * normal termination of the memcached instance.
5365  */
5366 static test_return_t wrong_failure_counter_test(memcached_st *memc)
5367 {
5368   memcached_return_t rc;
5369
5370   /* Set value to force connection to the server */
5371   const char *key= "marmotte";
5372   const char *value= "milka";
5373
5374   /*
5375    * Please note that I'm abusing the internal structures in libmemcached
5376    * in a non-portable way and you shouldn't be doing this. I'm only
5377    * doing this in order to verify that the library works the way it should
5378    */
5379   uint32_t number_of_hosts= memc->number_of_hosts;
5380   memc->number_of_hosts= 1;
5381
5382   /* Ensure that we are connected to the server by setting a value */
5383   rc= memcached_set(memc, key, strlen(key),
5384                     value, strlen(value),
5385                     (time_t)0, (uint32_t)0);
5386   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5387
5388
5389   /* The test is to see that the memcached_quit doesn't increase the
5390    * the server failure conter, so let's ensure that it is zero
5391    * before sending quit
5392    */
5393   memc->hosts[0].server_failure_counter= 0;
5394
5395   memcached_quit(memc);
5396
5397   /* Verify that it memcached_quit didn't increment the failure counter
5398    * Please note that this isn't bullet proof, because an error could
5399    * occur...
5400    */
5401   assert(memc->hosts[0].server_failure_counter == 0);
5402
5403   /* restore the instance */
5404   memc->number_of_hosts= number_of_hosts;
5405
5406   return TEST_SUCCESS;
5407 }
5408
5409 test_st udp_setup_server_tests[] ={
5410   {"set_udp_behavior_test", 0, (test_callback_fn)set_udp_behavior_test},
5411   {"add_tcp_server_udp_client_test", 0, (test_callback_fn)add_tcp_server_udp_client_test},
5412   {"add_udp_server_tcp_client_test", 0, (test_callback_fn)add_udp_server_tcp_client_test},
5413   {0, 0, 0}
5414 };
5415
5416 test_st upd_io_tests[] ={
5417   {"udp_set_test", 0, (test_callback_fn)udp_set_test},
5418   {"udp_buffered_set_test", 0, (test_callback_fn)udp_buffered_set_test},
5419   {"udp_set_too_big_test", 0, (test_callback_fn)udp_set_too_big_test},
5420   {"udp_delete_test", 0, (test_callback_fn)udp_delete_test},
5421   {"udp_buffered_delete_test", 0, (test_callback_fn)udp_buffered_delete_test},
5422   {"udp_verbosity_test", 0, (test_callback_fn)udp_verbosity_test},
5423   {"udp_quit_test", 0, (test_callback_fn)udp_quit_test},
5424   {"udp_flush_test", 0, (test_callback_fn)udp_flush_test},
5425   {"udp_incr_test", 0, (test_callback_fn)udp_incr_test},
5426   {"udp_decr_test", 0, (test_callback_fn)udp_decr_test},
5427   {"udp_stat_test", 0, (test_callback_fn)udp_stat_test},
5428   {"udp_version_test", 0, (test_callback_fn)udp_version_test},
5429   {"udp_get_test", 0, (test_callback_fn)udp_get_test},
5430   {"udp_mixed_io_test", 0, (test_callback_fn)udp_mixed_io_test},
5431   {0, 0, 0}
5432 };
5433
5434 /* Clean the server before beginning testing */
5435 test_st tests[] ={
5436   {"flush", 0, (test_callback_fn)flush_test },
5437   {"init", 0, (test_callback_fn)init_test },
5438   {"allocation", 0, (test_callback_fn)allocation_test },
5439   {"server_list_null_test", 0, (test_callback_fn)server_list_null_test},
5440   {"server_unsort", 0, (test_callback_fn)server_unsort_test},
5441   {"server_sort", 0, (test_callback_fn)server_sort_test},
5442   {"server_sort2", 0, (test_callback_fn)server_sort2_test},
5443   {"clone_test", 0, (test_callback_fn)clone_test },
5444   {"connection_test", 0, (test_callback_fn)connection_test},
5445   {"callback_test", 0, (test_callback_fn)callback_test},
5446   {"behavior_test", 0, (test_callback_fn)behavior_test},
5447   {"userdata_test", 0, (test_callback_fn)userdata_test},
5448   {"error", 0, (test_callback_fn)error_test },
5449   {"set", 0, (test_callback_fn)set_test },
5450   {"set2", 0, (test_callback_fn)set_test2 },
5451   {"set3", 0, (test_callback_fn)set_test3 },
5452   {"dump", 1, (test_callback_fn)dump_test},
5453   {"add", 1, (test_callback_fn)add_test },
5454   {"replace", 1, (test_callback_fn)replace_test },
5455   {"delete", 1, (test_callback_fn)delete_test },
5456   {"get", 1, (test_callback_fn)get_test },
5457   {"get2", 0, (test_callback_fn)get_test2 },
5458   {"get3", 0, (test_callback_fn)get_test3 },
5459   {"get4", 0, (test_callback_fn)get_test4 },
5460   {"partial mget", 0, (test_callback_fn)get_test5 },
5461   {"stats_servername", 0, (test_callback_fn)stats_servername_test },
5462   {"increment", 0, (test_callback_fn)increment_test },
5463   {"increment_with_initial", 1, (test_callback_fn)increment_with_initial_test },
5464   {"decrement", 0, (test_callback_fn)decrement_test },
5465   {"decrement_with_initial", 1, (test_callback_fn)decrement_with_initial_test },
5466   {"increment_by_key", 0, (test_callback_fn)increment_by_key_test },
5467   {"increment_with_initial_by_key", 1, (test_callback_fn)increment_with_initial_by_key_test },
5468   {"decrement_by_key", 0, (test_callback_fn)decrement_by_key_test },
5469   {"decrement_with_initial_by_key", 1, (test_callback_fn)decrement_with_initial_by_key_test },
5470   {"quit", 0, (test_callback_fn)quit_test },
5471   {"mget", 1, (test_callback_fn)mget_test },
5472   {"mget_result", 1, (test_callback_fn)mget_result_test },
5473   {"mget_result_alloc", 1, (test_callback_fn)mget_result_alloc_test },
5474   {"mget_result_function", 1, (test_callback_fn)mget_result_function },
5475   {"mget_execute", 1, (test_callback_fn)mget_execute },
5476   {"mget_end", 0, (test_callback_fn)mget_end },
5477   {"get_stats", 0, (test_callback_fn)get_stats },
5478   {"add_host_test", 0, (test_callback_fn)add_host_test },
5479   {"add_host_test_1", 0, (test_callback_fn)add_host_test1 },
5480   {"get_stats_keys", 0, (test_callback_fn)get_stats_keys },
5481   {"behavior_test", 0, (test_callback_fn)get_stats_keys },
5482   {"callback_test", 0, (test_callback_fn)get_stats_keys },
5483   {"version_string_test", 0, (test_callback_fn)version_string_test},
5484   {"bad_key", 1, (test_callback_fn)bad_key_test },
5485   {"memcached_server_cursor", 1, (test_callback_fn)memcached_server_cursor_test },
5486   {"read_through", 1, (test_callback_fn)read_through },
5487   {"delete_through", 1, (test_callback_fn)delete_through },
5488   {"noreply", 1, (test_callback_fn)noreply_test},
5489   {"analyzer", 1, (test_callback_fn)analyzer_test},
5490 #ifdef HAVE_LIBMEMCACHEDUTIL
5491   {"connectionpool", 1, (test_callback_fn)connection_pool_test },
5492 #endif
5493   {"test_get_last_disconnect", 1, (test_callback_fn)test_get_last_disconnect},
5494   {0, 0, 0}
5495 };
5496
5497 test_st async_tests[] ={
5498   {"add", 1, (test_callback_fn)add_wrapper },
5499   {0, 0, 0}
5500 };
5501
5502 test_st string_tests[] ={
5503   {"string static with null", 0, (test_callback_fn)string_static_null },
5504   {"string alloc with null", 0, (test_callback_fn)string_alloc_null },
5505   {"string alloc with 1K", 0, (test_callback_fn)string_alloc_with_size },
5506   {"string alloc with malloc failure", 0, (test_callback_fn)string_alloc_with_size_toobig },
5507   {"string append", 0, (test_callback_fn)string_alloc_append },
5508   {"string append failure (too big)", 0, (test_callback_fn)string_alloc_append_toobig },
5509   {0, 0, (test_callback_fn)0}
5510 };
5511
5512 test_st result_tests[] ={
5513   {"result static", 0, (test_callback_fn)result_static},
5514   {"result alloc", 0, (test_callback_fn)result_alloc},
5515   {0, 0, (test_callback_fn)0}
5516 };
5517
5518 test_st version_1_2_3[] ={
5519   {"append", 0, (test_callback_fn)append_test },
5520   {"prepend", 0, (test_callback_fn)prepend_test },
5521   {"cas", 0, (test_callback_fn)cas_test },
5522   {"cas2", 0, (test_callback_fn)cas2_test },
5523   {"append_binary", 0, (test_callback_fn)append_binary_test },
5524   {0, 0, (test_callback_fn)0}
5525 };
5526
5527 test_st user_tests[] ={
5528   {"user_supplied_bug1", 0, (test_callback_fn)user_supplied_bug1 },
5529   {"user_supplied_bug2", 0, (test_callback_fn)user_supplied_bug2 },
5530   {"user_supplied_bug3", 0, (test_callback_fn)user_supplied_bug3 },
5531   {"user_supplied_bug4", 0, (test_callback_fn)user_supplied_bug4 },
5532   {"user_supplied_bug5", 1, (test_callback_fn)user_supplied_bug5 },
5533   {"user_supplied_bug6", 1, (test_callback_fn)user_supplied_bug6 },
5534   {"user_supplied_bug7", 1, (test_callback_fn)user_supplied_bug7 },
5535   {"user_supplied_bug8", 1, (test_callback_fn)user_supplied_bug8 },
5536   {"user_supplied_bug9", 1, (test_callback_fn)user_supplied_bug9 },
5537   {"user_supplied_bug10", 1, (test_callback_fn)user_supplied_bug10 },
5538   {"user_supplied_bug11", 1, (test_callback_fn)user_supplied_bug11 },
5539   {"user_supplied_bug12", 1, (test_callback_fn)user_supplied_bug12 },
5540   {"user_supplied_bug13", 1, (test_callback_fn)user_supplied_bug13 },
5541   {"user_supplied_bug14", 1, (test_callback_fn)user_supplied_bug14 },
5542   {"user_supplied_bug15", 1, (test_callback_fn)user_supplied_bug15 },
5543   {"user_supplied_bug16", 1, (test_callback_fn)user_supplied_bug16 },
5544 #ifndef __sun
5545   /*
5546   ** It seems to be something weird with the character sets..
5547   ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5548   ** guess I need to find out how this is supposed to work.. Perhaps I need
5549   ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5550   ** so just disable the code for now...).
5551   */
5552   {"user_supplied_bug17", 1, (test_callback_fn)user_supplied_bug17 },
5553 #endif
5554   {"user_supplied_bug18", 1, (test_callback_fn)user_supplied_bug18 },
5555   {"user_supplied_bug19", 1, (test_callback_fn)user_supplied_bug19 },
5556   {"user_supplied_bug20", 1, (test_callback_fn)user_supplied_bug20 },
5557   {"user_supplied_bug21", 1, (test_callback_fn)user_supplied_bug21 },
5558   {"wrong_failure_counter_test", 1, (test_callback_fn)wrong_failure_counter_test},
5559   {0, 0, (test_callback_fn)0}
5560 };
5561
5562 test_st replication_tests[]= {
5563   {"set", 1, (test_callback_fn)replication_set_test },
5564   {"get", 0, (test_callback_fn)replication_get_test },
5565   {"mget", 0, (test_callback_fn)replication_mget_test },
5566   {"delete", 0, (test_callback_fn)replication_delete_test },
5567   {"rand_mget", 0, (test_callback_fn)replication_randomize_mget_test },
5568   {0, 0, (test_callback_fn)0}
5569 };
5570
5571 /*
5572  * The following test suite is used to verify that we don't introduce
5573  * regression bugs. If you want more information about the bug / test,
5574  * you should look in the bug report at
5575  *   http://bugs.launchpad.net/libmemcached
5576  */
5577 test_st regression_tests[]= {
5578   {"lp:434484", 1, (test_callback_fn)regression_bug_434484 },
5579   {"lp:434843", 1, (test_callback_fn)regression_bug_434843 },
5580   {"lp:434843 buffered", 1, (test_callback_fn)regression_bug_434843_buffered },
5581   {"lp:421108", 1, (test_callback_fn)regression_bug_421108 },
5582   {"lp:442914", 1, (test_callback_fn)regression_bug_442914 },
5583   {"lp:447342", 1, (test_callback_fn)regression_bug_447342 },
5584   {"lp:463297", 1, (test_callback_fn)regression_bug_463297 },
5585   {0, 0, (test_callback_fn)0}
5586 };
5587
5588 test_st ketama_compatibility[]= {
5589   {"libmemcached", 1, (test_callback_fn)ketama_compatibility_libmemcached },
5590   {"spymemcached", 1, (test_callback_fn)ketama_compatibility_spymemcached },
5591   {0, 0, (test_callback_fn)0}
5592 };
5593
5594 test_st generate_tests[] ={
5595   {"generate_pairs", 1, (test_callback_fn)generate_pairs },
5596   {"generate_data", 1, (test_callback_fn)generate_data },
5597   {"get_read", 0, (test_callback_fn)get_read },
5598   {"delete_generate", 0, (test_callback_fn)delete_generate },
5599   {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
5600   {"delete_buffer", 0, (test_callback_fn)delete_buffer_generate},
5601   {"generate_data", 1, (test_callback_fn)generate_data },
5602   {"mget_read", 0, (test_callback_fn)mget_read },
5603   {"mget_read_result", 0, (test_callback_fn)mget_read_result },
5604   {"mget_read_function", 0, (test_callback_fn)mget_read_function },
5605   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
5606   {"generate_large_pairs", 1, (test_callback_fn)generate_large_pairs },
5607   {"generate_data", 1, (test_callback_fn)generate_data },
5608   {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
5609   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
5610   {0, 0, (test_callback_fn)0}
5611 };
5612
5613 test_st consistent_tests[] ={
5614   {"generate_pairs", 1, (test_callback_fn)generate_pairs },
5615   {"generate_data", 1, (test_callback_fn)generate_data },
5616   {"get_read", 0, (test_callback_fn)get_read_count },
5617   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
5618   {0, 0, (test_callback_fn)0}
5619 };
5620
5621 test_st consistent_weighted_tests[] ={
5622   {"generate_pairs", 1, (test_callback_fn)generate_pairs },
5623   {"generate_data", 1, (test_callback_fn)generate_data_with_stats },
5624   {"get_read", 0, (test_callback_fn)get_read_count },
5625   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
5626   {0, 0, (test_callback_fn)0}
5627 };
5628
5629 test_st hsieh_availability[] ={
5630   {"hsieh_avaibility_test", 0, (test_callback_fn)hsieh_avaibility_test},
5631   {0, 0, (test_callback_fn)0}
5632 };
5633
5634 #if 0
5635 test_st hash_sanity[] ={
5636   {"hash sanity", 0, (test_callback_fn)hash_sanity_test},
5637   {0, 0, (test_callback_fn)0}
5638 };
5639 #endif
5640
5641 test_st ketama_auto_eject_hosts[] ={
5642   {"auto_eject_hosts", 1, (test_callback_fn)auto_eject_hosts },
5643   {"output_ketama_weighted_keys", 1, (test_callback_fn)output_ketama_weighted_keys },
5644   {0, 0, (test_callback_fn)0}
5645 };
5646
5647 test_st hash_tests[] ={
5648   {"md5", 0, (test_callback_fn)md5_run },
5649   {"crc", 0, (test_callback_fn)crc_run },
5650   {"fnv1_64", 0, (test_callback_fn)fnv1_64_run },
5651   {"fnv1a_64", 0, (test_callback_fn)fnv1a_64_run },
5652   {"fnv1_32", 0, (test_callback_fn)fnv1_32_run },
5653   {"fnv1a_32", 0, (test_callback_fn)fnv1a_32_run },
5654   {"hsieh", 0, (test_callback_fn)hsieh_run },
5655   {"murmur", 0, (test_callback_fn)murmur_run },
5656   {"jenkis", 0, (test_callback_fn)jenkins_run },
5657   {0, 0, (test_callback_fn)0}
5658 };
5659
5660 collection_st collection[] ={
5661 #if 0
5662   {"hash_sanity", 0, 0, hash_sanity},
5663 #endif
5664   {"hsieh_availability", 0, 0, hsieh_availability},
5665   {"udp_setup", (test_callback_fn)init_udp, 0, udp_setup_server_tests},
5666   {"udp_io", (test_callback_fn)init_udp, 0, upd_io_tests},
5667   {"udp_binary_io", (test_callback_fn)binary_init_udp, 0, upd_io_tests},
5668   {"block", 0, 0, tests},
5669   {"binary", (test_callback_fn)pre_binary, 0, tests},
5670   {"nonblock", (test_callback_fn)pre_nonblock, 0, tests},
5671   {"nodelay", (test_callback_fn)pre_nodelay, 0, tests},
5672   {"settimer", (test_callback_fn)pre_settimer, 0, tests},
5673   {"md5", (test_callback_fn)pre_md5, 0, tests},
5674   {"crc", (test_callback_fn)pre_crc, 0, tests},
5675   {"hsieh", (test_callback_fn)pre_hsieh, 0, tests},
5676   {"jenkins", (test_callback_fn)pre_jenkins, 0, tests},
5677   {"fnv1_64", (test_callback_fn)pre_hash_fnv1_64, 0, tests},
5678   {"fnv1a_64", (test_callback_fn)pre_hash_fnv1a_64, 0, tests},
5679   {"fnv1_32", (test_callback_fn)pre_hash_fnv1_32, 0, tests},
5680   {"fnv1a_32", (test_callback_fn)pre_hash_fnv1a_32, 0, tests},
5681   {"ketama", (test_callback_fn)pre_behavior_ketama, 0, tests},
5682   {"ketama_auto_eject_hosts", (test_callback_fn)pre_behavior_ketama, 0, ketama_auto_eject_hosts},
5683   {"unix_socket", (test_callback_fn)pre_unix_socket, 0, tests},
5684   {"unix_socket_nodelay", (test_callback_fn)pre_nodelay, 0, tests},
5685   {"poll_timeout", (test_callback_fn)poll_timeout, 0, tests},
5686   {"gets", (test_callback_fn)enable_cas, 0, tests},
5687   {"consistent", (test_callback_fn)enable_consistent, 0, tests},
5688 #ifdef MEMCACHED_ENABLE_DEPRECATED
5689   {"deprecated_memory_allocators", (test_callback_fn)deprecated_set_memory_alloc, 0, tests},
5690 #endif
5691   {"memory_allocators", (test_callback_fn)set_memory_alloc, 0, tests},
5692   {"prefix", (test_callback_fn)set_prefix, 0, tests},
5693   {"version_1_2_3", (test_callback_fn)check_for_1_2_3, 0, version_1_2_3},
5694   {"string", 0, 0, string_tests},
5695   {"result", 0, 0, result_tests},
5696   {"async", (test_callback_fn)pre_nonblock, 0, async_tests},
5697   {"async_binary", (test_callback_fn)pre_nonblock_binary, 0, async_tests},
5698   {"user", 0, 0, user_tests},
5699   {"generate", 0, 0, generate_tests},
5700   {"generate_hsieh", (test_callback_fn)pre_hsieh, 0, generate_tests},
5701   {"generate_ketama", (test_callback_fn)pre_behavior_ketama, 0, generate_tests},
5702   {"generate_hsieh_consistent", (test_callback_fn)enable_consistent, 0, generate_tests},
5703   {"generate_md5", (test_callback_fn)pre_md5, 0, generate_tests},
5704   {"generate_murmur", (test_callback_fn)pre_murmur, 0, generate_tests},
5705   {"generate_jenkins", (test_callback_fn)pre_jenkins, 0, generate_tests},
5706   {"generate_nonblock", (test_callback_fn)pre_nonblock, 0, generate_tests},
5707   {"consistent_not", 0, 0, consistent_tests},
5708   {"consistent_ketama", (test_callback_fn)pre_behavior_ketama, 0, consistent_tests},
5709   {"consistent_ketama_weighted", (test_callback_fn)pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
5710   {"ketama_compat", 0, 0, ketama_compatibility},
5711   {"test_hashes", 0, 0, hash_tests},
5712   {"replication", (test_callback_fn)pre_replication, 0, replication_tests},
5713   {"replication_noblock", (test_callback_fn)pre_replication_noblock, 0, replication_tests},
5714   {"regression", 0, 0, regression_tests},
5715   {0, 0, 0, 0}
5716 };
5717
5718 #define SERVERS_TO_CREATE 5
5719
5720 #include "libmemcached_world.h"
5721
5722 void get_world(world_st *world)
5723 {
5724   world->collections= collection;
5725   world->collection_startup= (test_callback_fn)world_collection_startup;
5726   world->flush= (test_callback_fn)world_flush;
5727   world->pre_run= (test_callback_fn)world_pre_run;
5728   world->create= (test_callback_create_fn)world_create;
5729   world->post_run= (test_callback_fn)world_post_run;
5730   world->on_error= (test_callback_error_fn)world_on_error;
5731   world->destroy= (test_callback_fn)world_destroy;
5732   world->runner= &defualt_libmemcached_runner;
5733 }