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

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