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