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