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