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

   1 /*
   2   Sample test application.
   3 */
   4 #include <assert.h>
   5 #include <memcached.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <sys/time.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <unistd.h>
  13 #include <time.h>
  14 #include "server.h"
  15 #include "../lib/common.h"
  16 #include "../src/generator.h"
  17 #include "../src/execute.h"
  18
  19 #ifndef INT64_MAX
  20 #define INT64_MAX LONG_MAX
  21 #endif
  22 #ifndef INT32_MAX
  23 #define INT32_MAX INT_MAX
  24 #endif
  25
  26
  27 #include "test.h"
  28
  29 #define GLOBAL_COUNT 100000
  30 #define GLOBAL2_COUNT 1000
  31 static uint32_t global_count;
  32
  33 static pairs_st *global_pairs;
  34 static char *global_keys[GLOBAL_COUNT];
  35 static size_t global_keys_length[GLOBAL_COUNT];
  36
  37 uint8_t init_test(memcached_st *not_used)
  38 {
  39   memcached_st memc;
  40
  41   (void)memcached_create(&memc);
  42   memcached_free(&memc);
  43
  44   return 0;
  45 }
  46
  47 uint8_t server_list_null_test(memcached_st *ptr)
  48 {
  49   memcached_server_st *server_list;
  50   memcached_return rc;
  51
  52   server_list= memcached_server_list_append(NULL, NULL, 0, NULL);
  53   assert(server_list == NULL);
  54
  55   server_list= memcached_server_list_append(NULL, "localhost", 0, NULL);
  56   assert(server_list == NULL);
  57
  58   server_list= memcached_server_list_append(NULL, NULL, 0, &rc);
  59   assert(server_list == NULL);
  60
  61   return 0;
  62 }
  63
  64 uint8_t server_sort_test(memcached_st *ptr)
  65 {
  66   memcached_server_st *server_list;
  67   memcached_return rc;
  68
  69   server_list= memcached_server_list_append(NULL, "arg", 0, &rc);
  70   assert(server_list);
  71
  72   server_list= memcached_server_list_append(server_list, "localhost", 0, &rc);
  73   assert(server_list);
  74
  75   server_list= memcached_server_list_append(server_list, "c", 0, &rc);
  76   assert(server_list);
  77
  78   server_list= memcached_server_list_append(server_list, "abba", 0, &rc);
  79   assert(server_list);
  80
  81   free(server_list);
  82
  83   return 0;
  84 }
  85
  86 uint8_t allocation_test(memcached_st *not_used)
  87 {
  88   memcached_st *memc;
  89   memc= memcached_create(NULL);
  90   assert(memc);
  91   memcached_free(memc);
  92
  93   return 0;
  94 }
  95
  96 uint8_t clone_test(memcached_st *memc)
  97 {
  98   /* All null? */
  99   {
 100     memcached_st *clone;
 101     clone= memcached_clone(NULL, NULL);
 102     assert(clone);
 103     memcached_free(clone);
 104   }
 105
 106   /* Can we init from null? */
 107   {
 108     memcached_st *clone;
 109     clone= memcached_clone(NULL, memc);
 110     assert(clone);
 111     memcached_free(clone);
 112   }
 113
 114   /* Can we init from struct? */
 115   {
 116     memcached_st declared_clone;
 117     memcached_st *clone;
 118     clone= memcached_clone(&declared_clone, NULL);
 119     assert(clone);
 120     memcached_free(clone);
 121   }
 122
 123   /* Can we init from struct? */
 124   {
 125     memcached_st declared_clone;
 126     memcached_st *clone;
 127     clone= memcached_clone(&declared_clone, memc);
 128     assert(clone);
 129     memcached_free(clone);
 130   }
 131
 132   return 0;
 133 }
 134
 135 uint8_t connection_test(memcached_st *memc)
 136 {
 137   memcached_return rc;
 138
 139   rc= memcached_server_add(memc, "localhost", 0);
 140   assert(rc == MEMCACHED_SUCCESS);
 141
 142   return 0;
 143 }
 144
 145 uint8_t error_test(memcached_st *memc)
 146 {
 147   memcached_return rc;
 148
 149   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
 150   {
 151     printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
 152   }
 153
 154   return 0;
 155 }
 156
 157 uint8_t set_test(memcached_st *memc)
 158 {
 159   memcached_return rc;
 160   char *key= "foo";
 161   char *value= "when we sanitize";
 162
 163   rc= memcached_set(memc, key, strlen(key),
 164                     value, strlen(value),
 165                     (time_t)0, (uint32_t)0);
 166   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 167
 168   return 0;
 169 }
 170
 171 uint8_t append_test(memcached_st *memc)
 172 {
 173   memcached_return rc;
 174   char *key= "fig";
 175   char *value= "we";
 176   size_t value_length;
 177   uint32_t flags;
 178
 179   rc= memcached_flush(memc, 0);
 180   assert(rc == MEMCACHED_SUCCESS);
 181
 182   rc= memcached_set(memc, key, strlen(key),
 183                     value, strlen(value),
 184                     (time_t)0, (uint32_t)0);
 185   assert(rc == MEMCACHED_SUCCESS);
 186
 187   rc= memcached_append(memc, key, strlen(key),
 188                        " the", strlen(" the"),
 189                        (time_t)0, (uint32_t)0);
 190   assert(rc == MEMCACHED_SUCCESS);
 191
 192   rc= memcached_append(memc, key, strlen(key),
 193                        " people", strlen(" people"),
 194                        (time_t)0, (uint32_t)0);
 195   assert(rc == MEMCACHED_SUCCESS);
 196
 197   value= memcached_get(memc, key, strlen(key),
 198                        &value_length, &flags, &rc);
 199   assert(!memcmp(value, "we the people", strlen("we the people")));
 200   assert(strlen("we the people") == value_length);
 201   assert(rc == MEMCACHED_SUCCESS);
 202   free(value);
 203
 204   return 0;
 205 }
 206
 207 uint8_t append_binary_test(memcached_st *memc)
 208 {
 209   memcached_return rc;
 210   char *key= "numbers";
 211   unsigned int *store_ptr;
 212   unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
 213   char *value;
 214   size_t value_length;
 215   uint32_t flags;
 216   unsigned int x;
 217
 218   rc= memcached_flush(memc, 0);
 219   assert(rc == MEMCACHED_SUCCESS);
 220
 221   rc= memcached_set(memc,
 222                     key, strlen(key),
 223                     NULL, 0,
 224                     (time_t)0, (uint32_t)0);
 225   assert(rc == MEMCACHED_SUCCESS);
 226
 227   for (x= 0; store_list[x] ; x++)
 228   {
 229     rc= memcached_append(memc,
 230                          key, strlen(key),
 231                          (char *)&store_list[x], sizeof(unsigned int),
 232                          (time_t)0, (uint32_t)0);
 233     assert(rc == MEMCACHED_SUCCESS);
 234   }
 235
 236   value= memcached_get(memc, key, strlen(key),
 237                        &value_length, &flags, &rc);
 238   assert((value_length == (sizeof(unsigned int) * x)));
 239   assert(rc == MEMCACHED_SUCCESS);
 240
 241   store_ptr= (unsigned int *)value;
 242   x= 0;
 243   while ((size_t)store_ptr < (size_t)(value + value_length))
 244   {
 245     assert(*store_ptr == store_list[x++]);
 246     store_ptr++;
 247   }
 248   free(value);
 249
 250   return 0;
 251 }
 252
 253 uint8_t cas2_test(memcached_st *memc)
 254 {
 255   memcached_return rc;
 256   char *keys[]= {"fudge", "son", "food"};
 257   size_t key_length[]= {5, 3, 4};
 258   char *value= "we the people";
 259   size_t value_length= strlen("we the people");
 260   unsigned int x;
 261   memcached_result_st results_obj;
 262   memcached_result_st *results;
 263   unsigned int set= 1;
 264
 265   rc= memcached_flush(memc, 0);
 266   assert(rc == MEMCACHED_SUCCESS);
 267
 268   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
 269
 270   for (x= 0; x < 3; x++)
 271   {
 272     rc= memcached_set(memc, keys[x], key_length[x],
 273                       keys[x], key_length[x],
 274                       (time_t)50, (uint32_t)9);
 275     assert(rc == MEMCACHED_SUCCESS);
 276   }
 277
 278   rc= memcached_mget(memc, keys, key_length, 3);
 279
 280   results= memcached_result_create(memc, &results_obj);
 281
 282   results= memcached_fetch_result(memc, &results_obj, &rc);
 283   assert(results);
 284   assert(results->cas);
 285   assert(rc == MEMCACHED_SUCCESS);
 286   WATCHPOINT_ASSERT(memcached_result_cas(results));
 287
 288   assert(!memcmp(value, "we the people", strlen("we the people")));
 289   assert(strlen("we the people") == value_length);
 290   assert(rc == MEMCACHED_SUCCESS);
 291
 292   memcached_result_free(&results_obj);
 293
 294   return 0;
 295 }
 296
 297 uint8_t cas_test(memcached_st *memc)
 298 {
 299   memcached_return rc;
 300   char *key= "fun";
 301   size_t key_length= strlen("fun");
 302   char *value= "we the people";
 303   size_t value_length= strlen("we the people");
 304   memcached_result_st results_obj;
 305   memcached_result_st *results;
 306   unsigned int set= 1;
 307
 308   rc= memcached_flush(memc, 0);
 309   assert(rc == MEMCACHED_SUCCESS);
 310
 311   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
 312
 313   rc= memcached_set(memc, key, strlen(key),
 314                     value, strlen(value),
 315                     (time_t)0, (uint32_t)0);
 316   assert(rc == MEMCACHED_SUCCESS);
 317
 318   rc= memcached_mget(memc, &key, &key_length, 1);
 319
 320   results= memcached_result_create(memc, &results_obj);
 321
 322   results= memcached_fetch_result(memc, &results_obj, &rc);
 323   assert(results);
 324   assert(rc == MEMCACHED_SUCCESS);
 325   WATCHPOINT_ASSERT(memcached_result_cas(results));
 326
 327   assert(!memcmp(value, "we the people", strlen("we the people")));
 328   assert(strlen("we the people") == value_length);
 329   assert(rc == MEMCACHED_SUCCESS);
 330
 331   memcached_result_free(&results_obj);
 332
 333   return 0;
 334 }
 335
 336 uint8_t prepend_test(memcached_st *memc)
 337 {
 338   memcached_return rc;
 339   char *key= "fig";
 340   char *value= "people";
 341   size_t value_length;
 342   uint32_t flags;
 343
 344   rc= memcached_flush(memc, 0);
 345   assert(rc == MEMCACHED_SUCCESS);
 346
 347   rc= memcached_set(memc, key, strlen(key),
 348                     value, strlen(value),
 349                     (time_t)0, (uint32_t)0);
 350   assert(rc == MEMCACHED_SUCCESS);
 351
 352   rc= memcached_prepend(memc, key, strlen(key),
 353                        "the ", strlen("the "),
 354                        (time_t)0, (uint32_t)0);
 355   assert(rc == MEMCACHED_SUCCESS);
 356
 357   rc= memcached_prepend(memc, key, strlen(key),
 358                        "we ", strlen("we "),
 359                        (time_t)0, (uint32_t)0);
 360   assert(rc == MEMCACHED_SUCCESS);
 361
 362   value= memcached_get(memc, key, strlen(key),
 363                        &value_length, &flags, &rc);
 364   assert(!memcmp(value, "we the people", strlen("we the people")));
 365   assert(strlen("we the people") == value_length);
 366   assert(rc == MEMCACHED_SUCCESS);
 367   free(value);
 368
 369   return 0;
 370 }
 371
 372 /*
 373   Set the value, then quit to make sure it is flushed.
 374   Come back in and test that add fails.
 375 */
 376 uint8_t add_test(memcached_st *memc)
 377 {
 378   memcached_return rc;
 379   char *key= "foo";
 380   char *value= "when we sanitize";
 381   unsigned long long setting_value;
 382
 383   setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 384
 385   rc= memcached_set(memc, key, strlen(key),
 386                     value, strlen(value),
 387                     (time_t)0, (uint32_t)0);
 388   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 389   memcached_quit(memc);
 390   rc= memcached_add(memc, key, strlen(key),
 391                     value, strlen(value),
 392                     (time_t)0, (uint32_t)0);
 393
 394   /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
 395   if (setting_value)
 396     assert(rc == MEMCACHED_NOTSTORED || MEMCACHED_STORED);
 397   else
 398     assert(rc == MEMCACHED_NOTSTORED);
 399
 400   return 0;
 401 }
 402
 403 uint8_t add_wrapper(memcached_st *memc)
 404 {
 405   unsigned int x;
 406
 407   for (x= 0; x < 10000; x++)
 408     add_test(memc);
 409
 410   return 0;
 411 }
 412
 413 uint8_t replace_test(memcached_st *memc)
 414 {
 415   memcached_return rc;
 416   char *key= "foo";
 417   char *value= "when we sanitize";
 418   char *original= "first we insert some data";
 419
 420   rc= memcached_set(memc, key, strlen(key),
 421                     original, strlen(original),
 422                     (time_t)0, (uint32_t)0);
 423   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 424
 425   rc= memcached_replace(memc, key, strlen(key),
 426                     value, strlen(value),
 427                     (time_t)0, (uint32_t)0);
 428   assert(rc == MEMCACHED_SUCCESS);
 429
 430   return 0;
 431 }
 432
 433 uint8_t delete_test(memcached_st *memc)
 434 {
 435   memcached_return rc;
 436   char *key= "foo";
 437   char *value= "when we sanitize";
 438
 439   rc= memcached_set(memc, key, strlen(key),
 440                     value, strlen(value),
 441                     (time_t)0, (uint32_t)0);
 442   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 443
 444   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 445   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 446
 447   return 0;
 448 }
 449
 450 uint8_t flush_test(memcached_st *memc)
 451 {
 452   memcached_return rc;
 453
 454   rc= memcached_flush(memc, 0);
 455   assert(rc == MEMCACHED_SUCCESS);
 456
 457   return 0;
 458 }
 459
 460 uint8_t bad_key_test(memcached_st *memc)
 461 {
 462 #ifdef HAVE_DEBUG
 463   memcached_return rc;
 464   char *key= "foo bad";
 465   char *string;
 466   size_t string_length;
 467   uint32_t flags;
 468
 469   string= memcached_get(memc, key, strlen(key),
 470                         &string_length, &flags, &rc);
 471   assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 472   assert(string_length ==  0);
 473   assert(!string);
 474 #endif
 475
 476   return 0;
 477 }
 478
 479 uint8_t get_test(memcached_st *memc)
 480 {
 481   memcached_return rc;
 482   char *key= "foo";
 483   char *string;
 484   size_t string_length;
 485   uint32_t flags;
 486
 487   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 488   assert(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);
 489
 490   string= memcached_get(memc, key, strlen(key),
 491                         &string_length, &flags, &rc);
 492
 493   assert(rc == MEMCACHED_NOTFOUND);
 494   assert(string_length ==  0);
 495   assert(!string);
 496
 497   return 0;
 498 }
 499
 500 uint8_t get_test2(memcached_st *memc)
 501 {
 502   memcached_return rc;
 503   char *key= "foo";
 504   char *value= "when we sanitize";
 505   char *string;
 506   size_t string_length;
 507   uint32_t flags;
 508
 509   rc= memcached_set(memc, key, strlen(key),
 510                     value, strlen(value),
 511                     (time_t)0, (uint32_t)0);
 512   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 513
 514   string= memcached_get(memc, key, strlen(key),
 515                         &string_length, &flags, &rc);
 516
 517   assert(string);
 518   assert(rc == MEMCACHED_SUCCESS);
 519   assert(string_length == strlen(value));
 520   assert(!memcmp(string, value, string_length));
 521
 522   free(string);
 523
 524   return 0;
 525 }
 526
 527 uint8_t set_test2(memcached_st *memc)
 528 {
 529   memcached_return rc;
 530   char *key= "foo";
 531   char *value= "train in the brain";
 532   size_t value_length= strlen(value);
 533   unsigned int x;
 534
 535   for (x= 0; x < 10; x++)
 536   {
 537     rc= memcached_set(memc, key, strlen(key),
 538                       value, value_length,
 539                       (time_t)0, (uint32_t)0);
 540     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 541   }
 542
 543   return 0;
 544 }
 545
 546 uint8_t set_test3(memcached_st *memc)
 547 {
 548   memcached_return rc;
 549   char *key= "foo";
 550   char *value;
 551   size_t value_length= 8191;
 552   unsigned int x;
 553
 554   value = (char*)malloc(value_length);
 555   assert(value);
 556
 557   for (x= 0; x < value_length; x++)
 558     value[x] = (char) (x % 127);
 559
 560   for (x= 0; x < 1; x++)
 561   {
 562     rc= memcached_set(memc, key, strlen(key),
 563                       value, value_length,
 564                       (time_t)0, (uint32_t)0);
 565     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 566   }
 567
 568   free(value);
 569
 570   return 0;
 571 }
 572
 573 uint8_t get_test3(memcached_st *memc)
 574 {
 575   memcached_return rc;
 576   char *key= "foo";
 577   char *value;
 578   size_t value_length= 8191;
 579   char *string;
 580   size_t string_length;
 581   uint32_t flags;
 582   int x;
 583
 584   value = (char*)malloc(value_length);
 585   assert(value);
 586
 587   for (x= 0; x < value_length; x++)
 588     value[x] = (char) (x % 127);
 589
 590   rc= memcached_set(memc, key, strlen(key),
 591                     value, value_length,
 592                     (time_t)0, (uint32_t)0);
 593   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 594
 595   string= memcached_get(memc, key, strlen(key),
 596                         &string_length, &flags, &rc);
 597
 598   assert(rc == MEMCACHED_SUCCESS);
 599   assert(string);
 600   assert(string_length == value_length);
 601   assert(!memcmp(string, value, string_length));
 602
 603   free(string);
 604   free(value);
 605
 606   return 0;
 607 }
 608
 609 uint8_t get_test4(memcached_st *memc)
 610 {
 611   memcached_return rc;
 612   char *key= "foo";
 613   char *value;
 614   size_t value_length= 8191;
 615   char *string;
 616   size_t string_length;
 617   uint32_t flags;
 618   int x;
 619
 620   value = (char*)malloc(value_length);
 621   assert(value);
 622
 623   for (x= 0; x < value_length; x++)
 624     value[x] = (char) (x % 127);
 625
 626   rc= memcached_set(memc, key, strlen(key),
 627                     value, value_length,
 628                     (time_t)0, (uint32_t)0);
 629   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 630
 631   for (x= 0; x < 10; x++)
 632   {
 633     string= memcached_get(memc, key, strlen(key),
 634                           &string_length, &flags, &rc);
 635
 636     assert(rc == MEMCACHED_SUCCESS);
 637     assert(string);
 638     assert(string_length == value_length);
 639     assert(!memcmp(string, value, string_length));
 640     free(string);
 641   }
 642
 643   free(value);
 644
 645   return 0;
 646 }
 647
 648 /* Do not copy the style of this code, I just access hosts to testthis function */
 649 uint8_t stats_servername_test(memcached_st *memc)
 650 {
 651   memcached_return rc;
 652   memcached_stat_st stat;
 653   rc= memcached_stat_servername(&stat, NULL,
 654                                  memc->hosts[0].hostname,
 655                                  memc->hosts[0].port);
 656
 657   return 0;
 658 }
 659
 660 uint8_t increment_test(memcached_st *memc)
 661 {
 662   uint64_t new_number;
 663   memcached_return rc;
 664   char *key= "number";
 665   char *value= "0";
 666
 667   rc= memcached_set(memc, key, strlen(key),
 668                     value, strlen(value),
 669                     (time_t)0, (uint32_t)0);
 670   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 671
 672   rc= memcached_increment(memc, key, strlen(key),
 673                           1, &new_number);
 674   assert(rc == MEMCACHED_SUCCESS);
 675   assert(new_number == 1);
 676
 677   rc= memcached_increment(memc, key, strlen(key),
 678                           1, &new_number);
 679   assert(rc == MEMCACHED_SUCCESS);
 680   assert(new_number == 2);
 681
 682   return 0;
 683 }
 684
 685 uint8_t decrement_test(memcached_st *memc)
 686 {
 687   uint64_t new_number;
 688   memcached_return rc;
 689   char *key= "number";
 690   char *value= "3";
 691
 692   rc= memcached_set(memc, key, strlen(key),
 693                     value, strlen(value),
 694                     (time_t)0, (uint32_t)0);
 695   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 696
 697   rc= memcached_decrement(memc, key, strlen(key),
 698                           1, &new_number);
 699   assert(rc == MEMCACHED_SUCCESS);
 700   assert(new_number == 2);
 701
 702   rc= memcached_decrement(memc, key, strlen(key),
 703                           1, &new_number);
 704   assert(rc == MEMCACHED_SUCCESS);
 705   assert(new_number == 1);
 706
 707   return 0;
 708 }
 709
 710 uint8_t quit_test(memcached_st *memc)
 711 {
 712   memcached_return rc;
 713   char *key= "fudge";
 714   char *value= "sanford and sun";
 715
 716   rc= memcached_set(memc, key, strlen(key),
 717                     value, strlen(value),
 718                     (time_t)10, (uint32_t)3);
 719   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 720   memcached_quit(memc);
 721
 722   rc= memcached_set(memc, key, strlen(key),
 723                     value, strlen(value),
 724                     (time_t)50, (uint32_t)9);
 725   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 726
 727   return 0;
 728 }
 729
 730 uint8_t mget_result_test(memcached_st *memc)
 731 {
 732   memcached_return rc;
 733   char *keys[]= {"fudge", "son", "food"};
 734   size_t key_length[]= {5, 3, 4};
 735   unsigned int x;
 736
 737   memcached_result_st results_obj;
 738   memcached_result_st *results;
 739
 740   results= memcached_result_create(memc, &results_obj);
 741   assert(results);
 742   assert(&results_obj == results);
 743
 744   /* We need to empty the server before continueing test */
 745   rc= memcached_flush(memc, 0);
 746   assert(rc == MEMCACHED_SUCCESS);
 747
 748   rc= memcached_mget(memc, keys, key_length, 3);
 749   assert(rc == MEMCACHED_SUCCESS);
 750
 751   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 752   {
 753     assert(results);
 754   }
 755
 756   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 757   assert(!results);
 758   assert(rc == MEMCACHED_END);
 759
 760   for (x= 0; x < 3; x++)
 761   {
 762     rc= memcached_set(memc, keys[x], key_length[x],
 763                       keys[x], key_length[x],
 764                       (time_t)50, (uint32_t)9);
 765     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 766   }
 767
 768   rc= memcached_mget(memc, keys, key_length, 3);
 769   assert(rc == MEMCACHED_SUCCESS);
 770
 771   while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
 772   {
 773     assert(results);
 774     assert(&results_obj == results);
 775     assert(rc == MEMCACHED_SUCCESS);
 776     assert(memcached_result_key_length(results) == memcached_result_length(results));
 777     assert(!memcmp(memcached_result_key_value(results),
 778                    memcached_result_value(results),
 779                    memcached_result_length(results)));
 780   }
 781
 782   memcached_result_free(&results_obj);
 783
 784   return 0;
 785 }
 786
 787 uint8_t mget_result_alloc_test(memcached_st *memc)
 788 {
 789   memcached_return rc;
 790   char *keys[]= {"fudge", "son", "food"};
 791   size_t key_length[]= {5, 3, 4};
 792   unsigned int x;
 793
 794   memcached_result_st *results;
 795
 796   /* We need to empty the server before continueing test */
 797   rc= memcached_flush(memc, 0);
 798   assert(rc == MEMCACHED_SUCCESS);
 799
 800   rc= memcached_mget(memc, keys, key_length, 3);
 801   assert(rc == MEMCACHED_SUCCESS);
 802
 803   while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
 804   {
 805     assert(results);
 806   }
 807   assert(!results);
 808   assert(rc == MEMCACHED_END);
 809
 810   for (x= 0; x < 3; x++)
 811   {
 812     rc= memcached_set(memc, keys[x], key_length[x],
 813                       keys[x], key_length[x],
 814                       (time_t)50, (uint32_t)9);
 815     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 816   }
 817
 818   rc= memcached_mget(memc, keys, key_length, 3);
 819   assert(rc == MEMCACHED_SUCCESS);
 820
 821   x= 0;
 822   while ((results= memcached_fetch_result(memc, NULL, &rc)))
 823   {
 824     assert(results);
 825     assert(rc == MEMCACHED_SUCCESS);
 826     assert(memcached_result_key_length(results) == memcached_result_length(results));
 827     assert(!memcmp(memcached_result_key_value(results),
 828                    memcached_result_value(results),
 829                    memcached_result_length(results)));
 830     memcached_result_free(results);
 831     x++;
 832   }
 833
 834   return 0;
 835 }
 836
 837 /* Count the results */
 838 unsigned int callback_counter(memcached_st *ptr, memcached_result_st *result, void *context)
 839 {
 840   unsigned int *counter= (unsigned int *)context;
 841
 842   *counter= *counter + 1;
 843
 844   return 0;
 845 }
 846
 847 uint8_t mget_result_function(memcached_st *memc)
 848 {
 849   memcached_return rc;
 850   char *keys[]= {"fudge", "son", "food"};
 851   size_t key_length[]= {5, 3, 4};
 852   unsigned int x;
 853   unsigned int counter;
 854   unsigned int (*callbacks[1])(memcached_st *, memcached_result_st *, void *);
 855
 856   /* We need to empty the server before continueing test */
 857   rc= memcached_flush(memc, 0);
 858   for (x= 0; x < 3; x++)
 859   {
 860     rc= memcached_set(memc, keys[x], key_length[x],
 861                       keys[x], key_length[x],
 862                       (time_t)50, (uint32_t)9);
 863     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 864   }
 865
 866   rc= memcached_mget(memc, keys, key_length, 3);
 867   assert(rc == MEMCACHED_SUCCESS);
 868
 869   callbacks[0]= &callback_counter;
 870   counter= 0;
 871   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
 872
 873   assert(counter == 3);
 874
 875   return 0;
 876 }
 877
 878 uint8_t mget_test(memcached_st *memc)
 879 {
 880   memcached_return rc;
 881   char *keys[]= {"fudge", "son", "food"};
 882   size_t key_length[]= {5, 3, 4};
 883   unsigned int x;
 884   uint32_t flags;
 885
 886   char return_key[MEMCACHED_MAX_KEY];
 887   size_t return_key_length;
 888   char *return_value;
 889   size_t return_value_length;
 890
 891   /* We need to empty the server before continueing test */
 892   rc= memcached_flush(memc, 0);
 893   assert(rc == MEMCACHED_SUCCESS);
 894
 895   rc= memcached_mget(memc, keys, key_length, 3);
 896   assert(rc == MEMCACHED_SUCCESS);
 897
 898   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 899                       &return_value_length, &flags, &rc)) != NULL)
 900   {
 901     assert(return_value);
 902   }
 903   assert(!return_value);
 904   assert(return_value_length == 0);
 905   assert(rc == MEMCACHED_END);
 906
 907   for (x= 0; x < 3; x++)
 908   {
 909     rc= memcached_set(memc, keys[x], key_length[x],
 910                       keys[x], key_length[x],
 911                       (time_t)50, (uint32_t)9);
 912     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 913   }
 914
 915   rc= memcached_mget(memc, keys, key_length, 3);
 916   assert(rc == MEMCACHED_SUCCESS);
 917
 918   x= 0;
 919   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 920                                         &return_value_length, &flags, &rc)))
 921   {
 922     assert(return_value);
 923     assert(rc == MEMCACHED_SUCCESS);
 924     assert(return_key_length == return_value_length);
 925     assert(!memcmp(return_value, return_key, return_value_length));
 926     free(return_value);
 927     x++;
 928   }
 929
 930   return 0;
 931 }
 932
 933 uint8_t get_stats_keys(memcached_st *memc)
 934 {
 935  char **list;
 936  char **ptr;
 937  memcached_stat_st stat;
 938  memcached_return rc;
 939
 940  list= memcached_stat_get_keys(memc, &stat, &rc);
 941  assert(rc == MEMCACHED_SUCCESS);
 942  for (ptr= list; *ptr; ptr++)
 943    assert(*ptr);
 944  fflush(stdout);
 945
 946  free(list);
 947
 948  return 0;
 949 }
 950
 951 uint8_t version_string_test(memcached_st *memc)
 952 {
 953   const char *version_string;
 954
 955   version_string= memcached_lib_version();
 956
 957   assert(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING));
 958
 959   return 0;
 960 }
 961
 962 uint8_t get_stats(memcached_st *memc)
 963 {
 964  unsigned int x;
 965  char **list;
 966  char **ptr;
 967  memcached_return rc;
 968  memcached_stat_st *stat;
 969
 970  stat= memcached_stat(memc, NULL, &rc);
 971  assert(rc == MEMCACHED_SUCCESS);
 972
 973  assert(rc == MEMCACHED_SUCCESS);
 974  assert(stat);
 975
 976  for (x= 0; x < memcached_server_count(memc); x++)
 977  {
 978    list= memcached_stat_get_keys(memc, stat+x, &rc);
 979    assert(rc == MEMCACHED_SUCCESS);
 980    for (ptr= list; *ptr; ptr++);
 981
 982    free(list);
 983  }
 984
 985  memcached_stat_free(NULL, stat);
 986
 987   return 0;
 988 }
 989
 990 uint8_t add_host_test(memcached_st *memc)
 991 {
 992   unsigned int x;
 993   memcached_server_st *servers;
 994   memcached_return rc;
 995   char servername[]= "0.example.com";
 996
 997   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 998   assert(servers);
 999   assert(1 == memcached_server_list_count(servers));
1000
1001   for (x= 2; x < 20; x++)
1002   {
1003     char buffer[SMALL_STRING_LEN];
1004
1005     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1006     servers= memcached_server_list_append(servers, buffer, 401,
1007                                      &rc);
1008     assert(rc == MEMCACHED_SUCCESS);
1009     assert(x == memcached_server_list_count(servers));
1010   }
1011
1012   rc= memcached_server_push(memc, servers);
1013   assert(rc == MEMCACHED_SUCCESS);
1014   rc= memcached_server_push(memc, servers);
1015   assert(rc == MEMCACHED_SUCCESS);
1016
1017   memcached_server_list_free(servers);
1018
1019   return 0;
1020 }
1021
1022 memcached_return clone_test_callback(memcached_st *parent, memcached_st *clone)
1023 {
1024   return MEMCACHED_SUCCESS;
1025 }
1026
1027 memcached_return cleanup_test_callback(memcached_st *ptr)
1028 {
1029   return MEMCACHED_SUCCESS;
1030 }
1031
1032 uint8_t callback_test(memcached_st *memc)
1033 {
1034   /* Test User Data */
1035   {
1036     int x= 5;
1037     int *test_ptr;
1038     memcached_return rc;
1039
1040     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x);
1041     assert(rc == MEMCACHED_SUCCESS);
1042     test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
1043     assert(*test_ptr == x);
1044   }
1045
1046   /* Test Clone Callback */
1047   {
1048     memcached_clone_func temp_function;
1049     memcached_return rc;
1050
1051     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, clone_test_callback);
1052     assert(rc == MEMCACHED_SUCCESS);
1053     temp_function= (memcached_clone_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1054     assert(temp_function == clone_test_callback);
1055   }
1056
1057   /* Test Cleanup Callback */
1058   {
1059     memcached_cleanup_func temp_function;
1060     memcached_return rc;
1061
1062     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, cleanup_test_callback);
1063     assert(rc == MEMCACHED_SUCCESS);
1064     temp_function= (memcached_cleanup_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1065     assert(temp_function == cleanup_test_callback);
1066   }
1067
1068   return 0;
1069 }
1070
1071 /* We don't test the behavior itself, we test the switches */
1072 uint8_t behavior_test(memcached_st *memc)
1073 {
1074   unsigned long long value;
1075   unsigned int set= 1;
1076
1077   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
1078   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1079   assert(value == 1);
1080
1081   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
1082   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1083   assert(value == 1);
1084
1085   set= MEMCACHED_HASH_MD5;
1086   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
1087   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1088   assert(value == MEMCACHED_HASH_MD5);
1089
1090   set= 0;
1091
1092   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
1093   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1094   assert(value == 0);
1095
1096   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
1097   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1098   assert(value == 0);
1099
1100   set= MEMCACHED_HASH_DEFAULT;
1101   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
1102   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1103   assert(value == MEMCACHED_HASH_DEFAULT);
1104
1105   set= MEMCACHED_HASH_CRC;
1106   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
1107   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1108   assert(value == MEMCACHED_HASH_CRC);
1109
1110   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1111   assert(value > 0);
1112
1113   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1114   assert(value > 0);
1115
1116   return 0;
1117 }
1118
1119 /* Test case provided by Cal Haldenbrand */
1120 uint8_t user_supplied_bug1(memcached_st *memc)
1121 {
1122   unsigned int setter= 1;
1123   unsigned int x;
1124
1125   unsigned long long total= 0;
1126   int size= 0;
1127   char key[10];
1128   char randomstuff[6 * 1024];
1129   memcached_return rc;
1130
1131   memset(randomstuff, 0, 6 * 1024);
1132
1133   /* We just keep looking at the same values over and over */
1134   srandom(10);
1135
1136   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
1137   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
1138
1139
1140   /* add key */
1141   for (x= 0 ; total < 20 * 1024576 ; x++ )
1142   {
1143     unsigned int j= 0;
1144
1145     size= (rand() % ( 5 * 1024 ) ) + 400;
1146     memset(randomstuff, 0, 6 * 1024);
1147     assert(size < 6 * 1024); /* Being safe here */
1148
1149     for (j= 0 ; j < size ;j++)
1150       randomstuff[j] = (char) (rand() % 26) + 97;
1151
1152     total += size;
1153     sprintf(key, "%d", x);
1154     rc = memcached_set(memc, key, strlen(key),
1155                        randomstuff, strlen(randomstuff), 10, 0);
1156     /* If we fail, lets try again */
1157     if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
1158       rc = memcached_set(memc, key, strlen(key),
1159                          randomstuff, strlen(randomstuff), 10, 0);
1160     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1161   }
1162
1163   return 0;
1164 }
1165
1166 /* Test case provided by Cal Haldenbrand */
1167 uint8_t user_supplied_bug2(memcached_st *memc)
1168 {
1169   int errors;
1170   unsigned int setter;
1171   unsigned int x;
1172   unsigned long long total;
1173
1174   setter= 1;
1175   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
1176   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
1177 #ifdef NOT_YET
1178   setter = 20 * 1024576;
1179   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
1180   setter = 20 * 1024576;
1181   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
1182   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1183   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1184
1185   for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
1186 #endif
1187
1188   for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
1189   {
1190     memcached_return rc= MEMCACHED_SUCCESS;
1191     char buffer[SMALL_STRING_LEN];
1192     uint32_t flags= 0;
1193     size_t val_len= 0;
1194     char *getval;
1195
1196     memset(buffer, 0, SMALL_STRING_LEN);
1197
1198     snprintf(buffer, SMALL_STRING_LEN, "%u", x);
1199     getval= memcached_get(memc, buffer, strlen(buffer),
1200                            &val_len, &flags, &rc);
1201     if (rc != MEMCACHED_SUCCESS)
1202     {
1203       if (rc == MEMCACHED_NOTFOUND)
1204         errors++;
1205       else
1206       {
1207         WATCHPOINT_ERROR(rc);
1208         assert(0);
1209       }
1210
1211       continue;
1212     }
1213     total+= val_len;
1214     errors= 0;
1215     free(getval);
1216   }
1217
1218   return 0;
1219 }
1220
1221 /* Do a large mget() over all the keys we think exist */
1222 #define KEY_COUNT 3000 // * 1024576
1223 uint8_t user_supplied_bug3(memcached_st *memc)
1224 {
1225   memcached_return rc;
1226   unsigned int setter;
1227   unsigned int x;
1228   char **keys;
1229   size_t key_lengths[KEY_COUNT];
1230
1231   setter= 1;
1232   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
1233   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
1234 #ifdef NOT_YET
1235   setter = 20 * 1024576;
1236   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
1237   setter = 20 * 1024576;
1238   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
1239   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1240   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1241 #endif
1242
1243   keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
1244   assert(keys);
1245   memset(keys, 0, (sizeof(char *) * KEY_COUNT));
1246   for (x= 0; x < KEY_COUNT; x++)
1247   {
1248     char buffer[30];
1249
1250     snprintf(buffer, 30, "%u", x);
1251     keys[x]= strdup(buffer);
1252     key_lengths[x]= strlen(keys[x]);
1253   }
1254
1255   rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
1256   assert(rc == MEMCACHED_SUCCESS);
1257
1258   /* Turn this into a help function */
1259   {
1260     char return_key[MEMCACHED_MAX_KEY];
1261     size_t return_key_length;
1262     char *return_value;
1263     size_t return_value_length;
1264     uint32_t flags;
1265
1266     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1267                                           &return_value_length, &flags, &rc)))
1268     {
1269       assert(return_value);
1270       assert(rc == MEMCACHED_SUCCESS);
1271       free(return_value);
1272     }
1273   }
1274
1275   for (x= 0; x < KEY_COUNT; x++)
1276     free(keys[x]);
1277   free(keys);
1278
1279   return 0;
1280 }
1281
1282 /* Make sure we behave properly if server list has no values */
1283 uint8_t user_supplied_bug4(memcached_st *memc)
1284 {
1285   memcached_return rc;
1286   char *keys[]= {"fudge", "son", "food"};
1287   size_t key_length[]= {5, 3, 4};
1288   unsigned int x;
1289   uint32_t flags;
1290   char return_key[MEMCACHED_MAX_KEY];
1291   size_t return_key_length;
1292   char *return_value;
1293   size_t return_value_length;
1294
1295   /* Here we free everything before running a bunch of mget tests */
1296   {
1297     memcached_server_list_free(memc->hosts);
1298     memc->hosts= NULL;
1299     memc->number_of_hosts= 0;
1300   }
1301
1302
1303   /* We need to empty the server before continueing test */
1304   rc= memcached_flush(memc, 0);
1305   assert(rc == MEMCACHED_NO_SERVERS);
1306
1307   rc= memcached_mget(memc, keys, key_length, 3);
1308   assert(rc == MEMCACHED_NO_SERVERS);
1309
1310   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1311                       &return_value_length, &flags, &rc)) != NULL)
1312   {
1313     assert(return_value);
1314   }
1315   assert(!return_value);
1316   assert(return_value_length == 0);
1317   assert(rc == MEMCACHED_NO_SERVERS);
1318
1319   for (x= 0; x < 3; x++)
1320   {
1321     rc= memcached_set(memc, keys[x], key_length[x],
1322                       keys[x], key_length[x],
1323                       (time_t)50, (uint32_t)9);
1324     assert(rc == MEMCACHED_NO_SERVERS);
1325   }
1326
1327   rc= memcached_mget(memc, keys, key_length, 3);
1328   assert(rc == MEMCACHED_NO_SERVERS);
1329
1330   x= 0;
1331   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1332                                         &return_value_length, &flags, &rc)))
1333   {
1334     assert(return_value);
1335     assert(rc == MEMCACHED_SUCCESS);
1336     assert(return_key_length == return_value_length);
1337     assert(!memcmp(return_value, return_key, return_value_length));
1338     free(return_value);
1339     x++;
1340   }
1341
1342   return 0;
1343 }
1344
1345 #define VALUE_SIZE_BUG5 1048064
1346 uint8_t user_supplied_bug5(memcached_st *memc)
1347 {
1348   memcached_return rc;
1349   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1350   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1351   char return_key[MEMCACHED_MAX_KEY];
1352   size_t return_key_length;
1353   char *value;
1354   size_t value_length;
1355   uint32_t flags;
1356   unsigned int count;
1357   unsigned int x;
1358   char insert_data[VALUE_SIZE_BUG5];
1359
1360   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1361     insert_data[x]= rand();
1362
1363   memcached_flush(memc, 0);
1364   value= memcached_get(memc, keys[0], key_length[0],
1365                         &value_length, &flags, &rc);
1366   assert(value == NULL);
1367   rc= memcached_mget(memc, keys, key_length, 4);
1368
1369   count= 0;
1370   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1371                                         &value_length, &flags, &rc)))
1372     count++;
1373   assert(count == 0);
1374
1375   for (x= 0; x < 4; x++)
1376   {
1377     rc= memcached_set(memc, keys[x], key_length[x],
1378                       insert_data, VALUE_SIZE_BUG5,
1379                       (time_t)0, (uint32_t)0);
1380     assert(rc == MEMCACHED_SUCCESS);
1381   }
1382
1383   for (x= 0; x < 10; x++)
1384   {
1385     value= memcached_get(memc, keys[0], key_length[0],
1386                          &value_length, &flags, &rc);
1387     assert(value);
1388     free(value);
1389
1390     rc= memcached_mget(memc, keys, key_length, 4);
1391     count= 0;
1392     while ((value= memcached_fetch(memc, return_key, &return_key_length,
1393                                           &value_length, &flags, &rc)))
1394     {
1395       count++;
1396       free(value);
1397     }
1398     assert(count == 4);
1399   }
1400
1401   return 0;
1402 }
1403
1404 uint8_t user_supplied_bug6(memcached_st *memc)
1405 {
1406   memcached_return rc;
1407   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1408   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1409   char return_key[MEMCACHED_MAX_KEY];
1410   size_t return_key_length;
1411   char *value;
1412   size_t value_length;
1413   uint32_t flags;
1414   unsigned int count;
1415   unsigned int x;
1416   char insert_data[VALUE_SIZE_BUG5];
1417
1418   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1419     insert_data[x]= rand();
1420
1421   memcached_flush(memc, 0);
1422   value= memcached_get(memc, keys[0], key_length[0],
1423                         &value_length, &flags, &rc);
1424   assert(value == NULL);
1425   assert(rc == MEMCACHED_NOTFOUND);
1426   rc= memcached_mget(memc, keys, key_length, 4);
1427   assert(rc == MEMCACHED_SUCCESS);
1428
1429   count= 0;
1430   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1431                                         &value_length, &flags, &rc)))
1432     count++;
1433   assert(count == 0);
1434   assert(rc == MEMCACHED_END);
1435
1436   for (x= 0; x < 4; x++)
1437   {
1438     rc= memcached_set(memc, keys[x], key_length[x],
1439                       insert_data, VALUE_SIZE_BUG5,
1440                       (time_t)0, (uint32_t)0);
1441     assert(rc == MEMCACHED_SUCCESS);
1442   }
1443
1444   for (x= 0; x < 2; x++)
1445   {
1446     value= memcached_get(memc, keys[0], key_length[0],
1447                          &value_length, &flags, &rc);
1448     assert(value);
1449     free(value);
1450
1451     rc= memcached_mget(memc, keys, key_length, 4);
1452     assert(rc == MEMCACHED_SUCCESS);
1453     count= 3;
1454     /* We test for purge of partial complete fetches */
1455     for (count= 3; count; count--)
1456     {
1457       value= memcached_fetch(memc, return_key, &return_key_length,
1458                              &value_length, &flags, &rc);
1459       assert(rc == MEMCACHED_SUCCESS);
1460       assert(!(memcmp(value, insert_data, value_length)));
1461       assert(value_length);
1462       free(value);
1463     }
1464   }
1465
1466   return 0;
1467 }
1468
1469 uint8_t user_supplied_bug8(memcached_st *memc)
1470 {
1471   memcached_return rc;
1472   memcached_st *mine;
1473   memcached_st *clone;
1474
1475   memcached_server_st *servers;
1476   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";
1477
1478   servers= memcached_servers_parse(server_list);
1479   assert(servers);
1480
1481   mine= memcached_create(NULL);
1482   rc= memcached_server_push(mine, servers);
1483   assert(rc == MEMCACHED_SUCCESS);
1484   memcached_server_list_free(servers);
1485
1486   assert(mine);
1487   clone= memcached_clone(NULL, mine);
1488
1489   memcached_quit(mine);
1490   memcached_quit(clone);
1491
1492
1493   memcached_free(mine);
1494   memcached_free(clone);
1495
1496   return 0;
1497 }
1498
1499 /* Test flag store/retrieve */
1500 uint8_t user_supplied_bug7(memcached_st *memc)
1501 {
1502   memcached_return rc;
1503   char *keys= "036790384900";
1504   size_t key_length=  strlen("036790384900");
1505   char return_key[MEMCACHED_MAX_KEY];
1506   size_t return_key_length;
1507   char *value;
1508   size_t value_length;
1509   uint32_t flags;
1510   unsigned int x;
1511   char insert_data[VALUE_SIZE_BUG5];
1512
1513   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1514     insert_data[x]= rand();
1515
1516   memcached_flush(memc, 0);
1517
1518   flags= 245;
1519   rc= memcached_set(memc, keys, key_length,
1520                     insert_data, VALUE_SIZE_BUG5,
1521                     (time_t)0, flags);
1522   assert(rc == MEMCACHED_SUCCESS);
1523
1524   flags= 0;
1525   value= memcached_get(memc, keys, key_length,
1526                         &value_length, &flags, &rc);
1527   assert(flags == 245);
1528   assert(value);
1529   free(value);
1530
1531   rc= memcached_mget(memc, &keys, &key_length, 1);
1532
1533   flags= 0;
1534   value= memcached_fetch(memc, return_key, &return_key_length,
1535                          &value_length, &flags, &rc);
1536   assert(flags == 245);
1537   assert(value);
1538   free(value);
1539
1540
1541   return 0;
1542 }
1543
1544 uint8_t user_supplied_bug9(memcached_st *memc)
1545 {
1546   memcached_return rc;
1547   char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1548   size_t key_length[3];
1549   unsigned int x;
1550   uint32_t flags;
1551   unsigned count= 0;
1552
1553   char return_key[MEMCACHED_MAX_KEY];
1554   size_t return_key_length;
1555   char *return_value;
1556   size_t return_value_length;
1557
1558
1559   key_length[0]= strlen("UDATA:edevil@sapo.pt");
1560   key_length[1]= strlen("fudge&*@#");
1561   key_length[2]= strlen("for^#@&$not");
1562
1563
1564   for (x= 0; x < 3; x++)
1565   {
1566     rc= memcached_set(memc, keys[x], key_length[x],
1567                       keys[x], key_length[x],
1568                       (time_t)50, (uint32_t)9);
1569     assert(rc == MEMCACHED_SUCCESS);
1570   }
1571
1572   rc= memcached_mget(memc, keys, key_length, 3);
1573   assert(rc == MEMCACHED_SUCCESS);
1574
1575   /* We need to empty the server before continueing test */
1576   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1577                       &return_value_length, &flags, &rc)) != NULL)
1578   {
1579     assert(return_value);
1580     free(return_value);
1581     count++;
1582   }
1583   assert(count == 3);
1584
1585   return 0;
1586 }
1587
1588 /* We are testing with aggressive timeout to get failures */
1589 uint8_t user_supplied_bug10(memcached_st *memc)
1590 {
1591   char *key= "foo";
1592   char *value;
1593   size_t value_length= 512;
1594   unsigned int x;
1595   int key_len= 3;
1596   memcached_return rc;
1597   unsigned int set= 1;
1598   memcached_st *mclone= memcached_clone(NULL, memc);
1599   int32_t timeout;
1600
1601   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
1602   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
1603   timeout= 2;
1604   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
1605
1606   value = (char*)malloc(value_length * sizeof(char));
1607
1608   for (x= 0; x < value_length; x++)
1609     value[x]= (char) (x % 127);
1610
1611   for (x= 1; x <= 100000; ++x)
1612   {
1613     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
1614
1615     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_BUFFERED);
1616
1617     if (rc == MEMCACHED_WRITE_FAILURE)
1618       x--;
1619   }
1620
1621   free(value);
1622   memcached_free(mclone);
1623
1624   return 0;
1625 }
1626
1627 /*
1628   We are looking failures in the async protocol
1629 */
1630 uint8_t user_supplied_bug11(memcached_st *memc)
1631 {
1632   char *key= "foo";
1633   char *value;
1634   size_t value_length= 512;
1635   unsigned int x;
1636   int key_len= 3;
1637   memcached_return rc;
1638   unsigned int set= 1;
1639   int32_t timeout;
1640   memcached_st *mclone= memcached_clone(NULL, memc);
1641
1642   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
1643   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
1644   timeout= -1;
1645   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
1646
1647   timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
1648
1649   assert(timeout == -1);
1650
1651   value = (char*)malloc(value_length * sizeof(char));
1652
1653   for (x= 0; x < value_length; x++)
1654     value[x]= (char) (x % 127);
1655
1656   for (x= 1; x <= 100000; ++x)
1657   {
1658     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
1659   }
1660
1661   free(value);
1662   memcached_free(mclone);
1663
1664   return 0;
1665 }
1666
1667 /*
1668   Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
1669 */
1670 uint8_t user_supplied_bug12(memcached_st *memc)
1671 {
1672   memcached_return rc;
1673   uint32_t flags;
1674   size_t value_length;
1675   char *value;
1676   uint64_t number_value;
1677
1678   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
1679                         &value_length, &flags, &rc);
1680   assert(value == NULL);
1681   assert(rc == MEMCACHED_NOTFOUND);
1682
1683   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
1684                           1, &number_value);
1685
1686   assert(value == NULL);
1687   assert(rc == MEMCACHED_NOTFOUND);
1688
1689   rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
1690
1691   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
1692                         &value_length, &flags, &rc);
1693   assert(value);
1694   assert(rc == MEMCACHED_SUCCESS);
1695   free(value);
1696
1697   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
1698                           1, &number_value);
1699   assert(number_value == 2);
1700   assert(rc == MEMCACHED_SUCCESS);
1701
1702   return 0;
1703 }
1704
1705 /*
1706   Bug found where command total one more than MEMCACHED_MAX_BUFFER
1707   set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
1708  */
1709 uint8_t user_supplied_bug13(memcached_st *memc)
1710 {
1711   char key[] = "key34567890";
1712   char *overflow;
1713   memcached_return rc;
1714   size_t overflowSize;
1715
1716   char commandFirst[]= "set key34567890 0 0 ";
1717   char commandLast[] = " \r\n"; /* first line of command sent to server */
1718   size_t commandLength;
1719   size_t testSize;
1720
1721   commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
1722
1723   overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
1724
1725   for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
1726   {
1727     overflow= malloc(testSize);
1728     assert(overflow != NULL);
1729
1730     memset(overflow, 'x', testSize);
1731     rc= memcached_set(memc, key, strlen(key),
1732                       overflow, testSize, 0, 0);
1733     assert(rc == MEMCACHED_SUCCESS);
1734     free(overflow);
1735   }
1736
1737   return 0;
1738 }
1739
1740
1741 /*
1742   Test values of many different sizes
1743   Bug found where command total one more than MEMCACHED_MAX_BUFFER
1744   set key34567890 0 0 8169 \r\n
1745   is sent followed by buffer of size 8169, followed by 8169
1746  */
1747 uint8_t user_supplied_bug14(memcached_st *memc)
1748 {
1749   int setter= 1;
1750   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
1751   memcached_return rc;
1752   char *key= "foo";
1753   char *value;
1754   size_t value_length= 18000;
1755   char *string;
1756   size_t string_length;
1757   uint32_t flags;
1758   unsigned int x;
1759   size_t current_length;
1760
1761   value = (char*)malloc(value_length);
1762   assert(value);
1763
1764   for (x= 0; x < value_length; x++)
1765     value[x] = (char) (x % 127);
1766
1767   for (current_length= 1; current_length < value_length; current_length++)
1768   {
1769     rc= memcached_set(memc, key, strlen(key),
1770                       value, current_length,
1771                       (time_t)0, (uint32_t)0);
1772     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1773
1774     string= memcached_get(memc, key, strlen(key),
1775                           &string_length, &flags, &rc);
1776
1777     assert(rc == MEMCACHED_SUCCESS);
1778     assert(string);
1779     assert(string_length == current_length);
1780     assert(!memcmp(string, value, string_length));
1781
1782     free(string);
1783   }
1784
1785   free(value);
1786
1787   return 0;
1788 }
1789
1790 uint8_t result_static(memcached_st *memc)
1791 {
1792   memcached_result_st result;
1793   memcached_result_st *result_ptr;
1794
1795   result_ptr= memcached_result_create(memc, &result);
1796   assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
1797   assert(result_ptr);
1798   memcached_result_free(&result);
1799
1800   return 0;
1801 }
1802
1803 uint8_t result_alloc(memcached_st *memc)
1804 {
1805   memcached_result_st *result;
1806
1807   result= memcached_result_create(memc, NULL);
1808   assert(result);
1809   memcached_result_free(result);
1810
1811   return 0;
1812 }
1813
1814 uint8_t string_static_null(memcached_st *memc)
1815 {
1816   memcached_string_st string;
1817   memcached_string_st *string_ptr;
1818
1819   string_ptr= memcached_string_create(memc, &string, 0);
1820   assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
1821   assert(string_ptr);
1822   memcached_string_free(&string);
1823
1824   return 0;
1825 }
1826
1827 uint8_t string_alloc_null(memcached_st *memc)
1828 {
1829   memcached_string_st *string;
1830
1831   string= memcached_string_create(memc, NULL, 0);
1832   assert(string);
1833   memcached_string_free(string);
1834
1835   return 0;
1836 }
1837
1838 uint8_t string_alloc_with_size(memcached_st *memc)
1839 {
1840   memcached_string_st *string;
1841
1842   string= memcached_string_create(memc, NULL, 1024);
1843   assert(string);
1844   memcached_string_free(string);
1845
1846   return 0;
1847 }
1848
1849 uint8_t string_alloc_with_size_toobig(memcached_st *memc)
1850 {
1851   memcached_string_st *string;
1852
1853   string= memcached_string_create(memc, NULL, INT64_MAX);
1854   assert(string == NULL);
1855
1856   return 0;
1857 }
1858
1859 uint8_t string_alloc_append(memcached_st *memc)
1860 {
1861   unsigned int x;
1862   char buffer[SMALL_STRING_LEN];
1863   memcached_string_st *string;
1864
1865   /* Ring the bell! */
1866   memset(buffer, 6, SMALL_STRING_LEN);
1867
1868   string= memcached_string_create(memc, NULL, 100);
1869   assert(string);
1870
1871   for (x= 0; x < 1024; x++)
1872   {
1873     memcached_return rc;
1874     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1875     assert(rc == MEMCACHED_SUCCESS);
1876   }
1877   memcached_string_free(string);
1878
1879   return 0;
1880 }
1881
1882 uint8_t string_alloc_append_toobig(memcached_st *memc)
1883 {
1884   memcached_return rc;
1885   unsigned int x;
1886   char buffer[SMALL_STRING_LEN];
1887   memcached_string_st *string;
1888
1889   /* Ring the bell! */
1890   memset(buffer, 6, SMALL_STRING_LEN);
1891
1892   string= memcached_string_create(memc, NULL, 100);
1893   assert(string);
1894
1895   for (x= 0; x < 1024; x++)
1896   {
1897     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1898     assert(rc == MEMCACHED_SUCCESS);
1899   }
1900   rc= memcached_string_append(string, buffer, INT64_MAX);
1901   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
1902   memcached_string_free(string);
1903
1904   return 0;
1905 }
1906
1907 uint8_t cleanup_pairs(memcached_st *memc)
1908 {
1909   pairs_free(global_pairs);
1910
1911   return 0;
1912 }
1913
1914 uint8_t generate_pairs(memcached_st *memc)
1915 {
1916   unsigned long long x;
1917   global_pairs= pairs_generate(GLOBAL_COUNT, 400);
1918   global_count= GLOBAL_COUNT;
1919
1920   for (x= 0; x < global_count; x++)
1921   {
1922     global_keys[x]= global_pairs[x].key;
1923     global_keys_length[x]=  global_pairs[x].key_length;
1924   }
1925
1926   return 0;
1927 }
1928
1929 uint8_t generate_large_pairs(memcached_st *memc)
1930 {
1931   unsigned long long x;
1932   global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
1933   global_count= GLOBAL2_COUNT;
1934
1935   for (x= 0; x < global_count; x++)
1936   {
1937     global_keys[x]= global_pairs[x].key;
1938     global_keys_length[x]=  global_pairs[x].key_length;
1939   }
1940
1941   return 0;
1942 }
1943
1944 uint8_t generate_data(memcached_st *memc)
1945 {
1946   execute_set(memc, global_pairs, global_count);
1947
1948   return 0;
1949 }
1950
1951 uint8_t generate_buffer_data(memcached_st *memc)
1952 {
1953   int latch= 0;
1954
1955   latch= 1;
1956   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, &latch);
1957   generate_data(memc);
1958
1959   return 0;
1960 }
1961
1962 uint8_t get_read(memcached_st *memc)
1963 {
1964   unsigned int x;
1965   memcached_return rc;
1966
1967   {
1968     char *return_value;
1969     size_t return_value_length;
1970     uint32_t flags;
1971
1972     for (x= 0; x < global_count; x++)
1973     {
1974       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
1975                                   &return_value_length, &flags, &rc);
1976       /*
1977       assert(return_value);
1978       assert(rc == MEMCACHED_SUCCESS);
1979     */
1980       if (rc == MEMCACHED_SUCCESS && return_value)
1981         free(return_value);
1982     }
1983   }
1984
1985   return 0;
1986 }
1987
1988 uint8_t mget_read(memcached_st *memc)
1989 {
1990   memcached_return rc;
1991
1992   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
1993   assert(rc == MEMCACHED_SUCCESS);
1994   /* Turn this into a help function */
1995   {
1996     char return_key[MEMCACHED_MAX_KEY];
1997     size_t return_key_length;
1998     char *return_value;
1999     size_t return_value_length;
2000     uint32_t flags;
2001
2002     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2003                                           &return_value_length, &flags, &rc)))
2004     {
2005       assert(return_value);
2006       assert(rc == MEMCACHED_SUCCESS);
2007       free(return_value);
2008     }
2009   }
2010
2011   return 0;
2012 }
2013
2014 uint8_t mget_read_result(memcached_st *memc)
2015 {
2016   memcached_return rc;
2017
2018   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2019   assert(rc == MEMCACHED_SUCCESS);
2020   /* Turn this into a help function */
2021   {
2022     memcached_result_st results_obj;
2023     memcached_result_st *results;
2024
2025     results= memcached_result_create(memc, &results_obj);
2026
2027     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
2028     {
2029       assert(results);
2030       assert(rc == MEMCACHED_SUCCESS);
2031     }
2032
2033     memcached_result_free(&results_obj);
2034   }
2035
2036   return 0;
2037 }
2038
2039 uint8_t mget_read_function(memcached_st *memc)
2040 {
2041   memcached_return rc;
2042   unsigned int counter;
2043   unsigned int (*callbacks[1])(memcached_st *, memcached_result_st *, void *);
2044
2045   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2046   assert(rc == MEMCACHED_SUCCESS);
2047
2048   callbacks[0]= &callback_counter;
2049   counter= 0;
2050   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
2051
2052   return 0;
2053 }
2054
2055 uint8_t delete_generate(memcached_st *memc)
2056 {
2057   unsigned int x;
2058
2059   for (x= 0; x < global_count; x++)
2060   {
2061     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2062   }
2063
2064   return 0;
2065 }
2066
2067 uint8_t delete_buffer_generate(memcached_st *memc)
2068 {
2069   int latch= 0;
2070   unsigned int x;
2071
2072   latch= 1;
2073   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, &latch);
2074
2075   for (x= 0; x < global_count; x++)
2076   {
2077     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2078   }
2079
2080   return 0;
2081 }
2082
2083 uint8_t free_data(memcached_st *memc)
2084 {
2085   pairs_free(global_pairs);
2086
2087   return 0;
2088 }
2089
2090 uint8_t add_host_test1(memcached_st *memc)
2091 {
2092   unsigned int x;
2093   memcached_return rc;
2094   char servername[]= "0.example.com";
2095   memcached_server_st *servers;
2096
2097   servers= memcached_server_list_append(NULL, servername, 400, &rc);
2098   assert(servers);
2099   assert(1 == memcached_server_list_count(servers));
2100
2101   for (x= 2; x < 20; x++)
2102   {
2103     char buffer[SMALL_STRING_LEN];
2104
2105     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
2106     servers= memcached_server_list_append(servers, buffer, 401,
2107                                      &rc);
2108     assert(rc == MEMCACHED_SUCCESS);
2109     assert(x == memcached_server_list_count(servers));
2110   }
2111
2112   rc= memcached_server_push(memc, servers);
2113   assert(rc == MEMCACHED_SUCCESS);
2114   rc= memcached_server_push(memc, servers);
2115   assert(rc == MEMCACHED_SUCCESS);
2116
2117   memcached_server_list_free(servers);
2118
2119   return 0;
2120 }
2121
2122 memcached_return pre_nonblock(memcached_st *memc)
2123 {
2124   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
2125
2126   return MEMCACHED_SUCCESS;
2127 }
2128
2129 memcached_return pre_md5(memcached_st *memc)
2130 {
2131   memcached_hash value= MEMCACHED_HASH_MD5;
2132   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2133
2134   return MEMCACHED_SUCCESS;
2135 }
2136
2137 memcached_return pre_crc(memcached_st *memc)
2138 {
2139   memcached_hash value= MEMCACHED_HASH_CRC;
2140   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2141
2142   return MEMCACHED_SUCCESS;
2143 }
2144
2145 memcached_return pre_hsieh(memcached_st *memc)
2146 {
2147   memcached_hash value= MEMCACHED_HASH_HSIEH;
2148   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2149
2150   return MEMCACHED_SUCCESS;
2151 }
2152
2153 memcached_return pre_hash_fnv1_64(memcached_st *memc)
2154 {
2155   memcached_hash value= MEMCACHED_HASH_FNV1_64;
2156   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2157
2158   return MEMCACHED_SUCCESS;
2159 }
2160
2161 memcached_return pre_hash_fnv1a_64(memcached_st *memc)
2162 {
2163   memcached_hash value= MEMCACHED_HASH_FNV1A_64;
2164   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2165
2166   return MEMCACHED_SUCCESS;
2167 }
2168
2169 memcached_return pre_hash_fnv1_32(memcached_st *memc)
2170 {
2171   memcached_hash value= MEMCACHED_HASH_FNV1_32;
2172   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2173
2174   return MEMCACHED_SUCCESS;
2175 }
2176
2177 memcached_return pre_hash_fnv1a_32(memcached_st *memc)
2178 {
2179   memcached_hash value= MEMCACHED_HASH_FNV1A_32;
2180   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2181
2182   return MEMCACHED_SUCCESS;
2183 }
2184
2185 memcached_return pre_hash_ketama(memcached_st *memc)
2186 {
2187   memcached_hash value= MEMCACHED_HASH_KETAMA;
2188   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2189
2190   return MEMCACHED_SUCCESS;
2191 }
2192
2193 void my_free(memcached_st *ptr, void *mem)
2194 {
2195   free(mem);
2196 }
2197
2198 void *my_malloc(memcached_st *ptr, const size_t size)
2199 {
2200   return malloc(size);
2201 }
2202
2203 void *my_realloc(memcached_st *ptr, void *mem, const size_t size)
2204 {
2205   return realloc(mem, size);
2206 }
2207
2208 memcached_return set_memory_alloc(memcached_st *memc)
2209 {
2210   {
2211     memcached_malloc_function test_ptr;
2212     memcached_return rc;
2213
2214     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &my_malloc);
2215     assert(rc == MEMCACHED_SUCCESS);
2216     test_ptr= (memcached_malloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
2217     assert(rc == MEMCACHED_SUCCESS);
2218     assert(test_ptr == my_malloc);
2219   }
2220
2221   {
2222     memcached_realloc_function test_ptr;
2223     memcached_return rc;
2224
2225     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &my_realloc);
2226     assert(rc == MEMCACHED_SUCCESS);
2227     test_ptr= (memcached_realloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
2228     assert(rc == MEMCACHED_SUCCESS);
2229     assert(test_ptr == my_realloc);
2230   }
2231
2232   {
2233     memcached_free_function test_ptr;
2234     memcached_return rc;
2235
2236     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, my_free);
2237     assert(rc == MEMCACHED_SUCCESS);
2238     test_ptr= (memcached_free_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
2239     assert(rc == MEMCACHED_SUCCESS);
2240     assert(test_ptr == my_free);
2241   }
2242
2243   return MEMCACHED_SUCCESS;
2244 }
2245
2246 memcached_return enable_consistent(memcached_st *memc)
2247 {
2248   memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;
2249   memcached_hash hash;
2250   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, &value);
2251   pre_hsieh(memc);
2252
2253   value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
2254   assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
2255
2256   hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
2257   assert(hash == MEMCACHED_HASH_HSIEH);
2258
2259
2260   return MEMCACHED_SUCCESS;
2261 }
2262
2263 memcached_return enable_cas(memcached_st *memc)
2264 {
2265   unsigned int set= 1;
2266
2267   memcached_version(memc);
2268
2269   if (memc->hosts[0].major_version >= 1 &&
2270       memc->hosts[0].minor_version >= 2 &&
2271       memc->hosts[0].micro_version >= 4)
2272   {
2273     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
2274
2275     return MEMCACHED_SUCCESS;
2276   }
2277
2278   return MEMCACHED_FAILURE;
2279 }
2280
2281 memcached_return check_for_1_2_3(memcached_st *memc)
2282 {
2283   memcached_version(memc);
2284
2285   if (memc->hosts[0].major_version >= 1 &&
2286       memc->hosts[0].minor_version >= 2 &&
2287       memc->hosts[0].micro_version >= 4)
2288     return MEMCACHED_SUCCESS;
2289
2290   return MEMCACHED_FAILURE;
2291 }
2292
2293 memcached_return pre_unix_socket(memcached_st *memc)
2294 {
2295   memcached_return rc;
2296   struct stat buf;
2297
2298   memcached_server_list_free(memc->hosts);
2299   memc->hosts= NULL;
2300   memc->number_of_hosts= 0;
2301
2302   if (stat("/tmp/memcached.socket", &buf))
2303     return MEMCACHED_FAILURE;
2304
2305   rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");
2306
2307   return rc;
2308 }
2309
2310 memcached_return pre_udp(memcached_st *memc)
2311 {
2312   memcached_return rc;
2313
2314   memcached_server_list_free(memc->hosts);
2315   memc->hosts= NULL;
2316   memc->number_of_hosts= 0;
2317
2318   if (0)
2319     return MEMCACHED_FAILURE;
2320
2321   rc= memcached_server_add_udp(memc, "localhost", MEMCACHED_DEFAULT_PORT);
2322
2323   return rc;
2324 }
2325
2326 memcached_return pre_nodelay(memcached_st *memc)
2327 {
2328   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
2329   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
2330
2331   return MEMCACHED_SUCCESS;
2332 }
2333
2334 memcached_return poll_timeout(memcached_st *memc)
2335 {
2336   int32_t timeout;
2337
2338   timeout= 100;
2339
2340   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
2341
2342   timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
2343
2344   assert(timeout == 100);
2345
2346   return MEMCACHED_SUCCESS;
2347 }
2348
2349
2350 /* Clean the server before beginning testing */
2351 test_st tests[] ={
2352   {"flush", 0, flush_test },
2353   {"init", 0, init_test },
2354   {"allocation", 0, allocation_test },
2355   {"server_list_null_test", 0, server_list_null_test},
2356   {"server_sort", 0, server_sort_test},
2357   {"clone_test", 0, clone_test },
2358   {"error", 0, error_test },
2359   {"set", 0, set_test },
2360   {"set2", 0, set_test2 },
2361   {"set3", 0, set_test3 },
2362   {"add", 1, add_test },
2363   {"replace", 1, replace_test },
2364   {"delete", 1, delete_test },
2365   {"get", 1, get_test },
2366   {"get2", 0, get_test2 },
2367   {"get3", 0, get_test3 },
2368   {"get4", 0, get_test4 },
2369   {"stats_servername", 0, stats_servername_test },
2370   {"increment", 0, increment_test },
2371   {"decrement", 0, decrement_test },
2372   {"quit", 0, quit_test },
2373   {"mget", 1, mget_test },
2374   {"mget_result", 1, mget_result_test },
2375   {"mget_result_alloc", 1, mget_result_alloc_test },
2376   {"mget_result_function", 1, mget_result_function },
2377   {"get_stats", 0, get_stats },
2378   {"add_host_test", 0, add_host_test },
2379   {"get_stats_keys", 0, get_stats_keys },
2380   {"behavior_test", 0, get_stats_keys },
2381   {"callback_test", 0, get_stats_keys },
2382   {"version_string_test", 0, version_string_test},
2383   {"bad_key", 1, bad_key_test },
2384   {0, 0, 0}
2385 };
2386
2387 test_st async_tests[] ={
2388   {"add", 1, add_wrapper },
2389   {0, 0, 0}
2390 };
2391
2392 test_st string_tests[] ={
2393   {"string static with null", 0, string_static_null },
2394   {"string alloc with null", 0, string_alloc_null },
2395   {"string alloc with 1K", 0, string_alloc_with_size },
2396   {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
2397   {"string append", 0, string_alloc_append },
2398   {"string append failure (too big)", 0, string_alloc_append_toobig },
2399   {0, 0, 0}
2400 };
2401
2402 test_st result_tests[] ={
2403   {"result static", 0, result_static},
2404   {"result alloc", 0, result_alloc},
2405   {0, 0, 0}
2406 };
2407
2408 test_st version_1_2_3[] ={
2409   {"append", 0, append_test },
2410   {"prepend", 0, prepend_test },
2411   {"cas", 0, cas_test },
2412   {"cas2", 0, cas2_test },
2413   {"append_binary", 0, append_binary_test },
2414   {0, 0, 0}
2415 };
2416
2417 test_st user_tests[] ={
2418   {"user_supplied_bug1", 0, user_supplied_bug1 },
2419   {"user_supplied_bug2", 0, user_supplied_bug2 },
2420   {"user_supplied_bug3", 0, user_supplied_bug3 },
2421   {"user_supplied_bug4", 0, user_supplied_bug4 },
2422   {"user_supplied_bug5", 1, user_supplied_bug5 },
2423   {"user_supplied_bug6", 1, user_supplied_bug6 },
2424   {"user_supplied_bug7", 1, user_supplied_bug7 },
2425   {"user_supplied_bug8", 1, user_supplied_bug8 },
2426   {"user_supplied_bug9", 1, user_supplied_bug9 },
2427   {"user_supplied_bug10", 1, user_supplied_bug10 },
2428   {"user_supplied_bug11", 1, user_supplied_bug11 },
2429   {"user_supplied_bug12", 1, user_supplied_bug12 },
2430   {"user_supplied_bug13", 1, user_supplied_bug13 },
2431   {"user_supplied_bug14", 1, user_supplied_bug14 },
2432   {0, 0, 0}
2433 };
2434
2435 test_st generate_tests[] ={
2436   {"generate_pairs", 1, generate_pairs },
2437   {"generate_data", 1, generate_data },
2438   {"get_read", 0, get_read },
2439   {"delete_generate", 0, delete_generate },
2440   {"generate_buffer_data", 1, generate_buffer_data },
2441   {"delete_buffer", 0, delete_buffer_generate},
2442   {"generate_data", 1, generate_data },
2443   {"mget_read", 0, mget_read },
2444   {"mget_read_result", 0, mget_read_result },
2445   {"mget_read_function", 0, mget_read_function },
2446   {"cleanup", 1, cleanup_pairs },
2447   {"generate_large_pairs", 1, generate_large_pairs },
2448   {"generate_data", 1, generate_data },
2449   {"generate_buffer_data", 1, generate_buffer_data },
2450   {"cleanup", 1, cleanup_pairs },
2451   {0, 0, 0}
2452 };
2453
2454
2455 collection_st collection[] ={
2456   {"block", 0, 0, tests},
2457   {"nonblock", pre_nonblock, 0, tests},
2458   {"nodelay", pre_nodelay, 0, tests},
2459   {"md5", pre_md5, 0, tests},
2460   {"crc", pre_crc, 0, tests},
2461   {"hsieh", pre_hsieh, 0, tests},
2462   {"fnv1_64", pre_hash_fnv1_64, 0, tests},
2463   {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
2464   {"fnv1_32", pre_hash_fnv1_32, 0, tests},
2465   {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
2466   {"ketama", pre_hash_ketama, 0, tests},
2467   {"unix_socket", pre_unix_socket, 0, tests},
2468   {"unix_socket_nodelay", pre_nodelay, 0, tests},
2469   {"poll_timeout", poll_timeout, 0, tests},
2470   {"gets", enable_cas, 0, tests},
2471   {"consistent", enable_consistent, 0, tests},
2472   {"memory_allocators", set_memory_alloc, 0, tests},
2473 //  {"udp", pre_udp, 0, tests},
2474   {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
2475   {"string", 0, 0, string_tests},
2476   {"result", 0, 0, result_tests},
2477   {"async", pre_nonblock, 0, async_tests},
2478   {"user", 0, 0, user_tests},
2479   {"generate", 0, 0, generate_tests},
2480   {"generate_hsieh", pre_hsieh, 0, generate_tests},
2481   {"generate_hsieh_consistent", enable_consistent, 0, generate_tests},
2482   {"generate_md5", pre_md5, 0, generate_tests},
2483   {"generate_nonblock", pre_nonblock, 0, generate_tests},
2484   {0, 0, 0, 0}
2485 };
2486
2487 #define SERVERS_TO_CREATE 5
2488
2489 void *world_create(void)
2490 {
2491   server_startup_st *construct;
2492
2493   construct= (server_startup_st *)malloc(sizeof(server_startup_st));
2494   memset(construct, 0, sizeof(server_startup_st));
2495   construct->count= SERVERS_TO_CREATE;
2496   construct->udp= 0;
2497   server_startup(construct);
2498
2499   return construct;
2500 }
2501
2502 void world_destroy(void *p)
2503 {
2504   server_startup_st *construct= (server_startup_st *)p;
2505   memcached_server_st *servers= (memcached_server_st *)construct->servers;
2506   memcached_server_list_free(servers);
2507
2508   server_shutdown(construct);
2509   free(construct);
2510 }
2511
2512 void get_world(world_st *world)
2513 {
2514   world->collections= collection;
2515   world->create= world_create;
2516   world->destroy= world_destroy;
2517 }