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