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, (uint16_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   uint16_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, (uint16_t)0);
 134   assert(rc == MEMCACHED_SUCCESS);
 135
 136   rc= memcached_append(memc, key, strlen(key),
 137                        " the", strlen(" the"),
 138                        (time_t)0, (uint16_t)0);
 139   assert(rc == MEMCACHED_SUCCESS);
 140
 141   rc= memcached_append(memc, key, strlen(key),
 142                        " people", strlen(" people"),
 143                        (time_t)0, (uint16_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   uint16_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, (uint16_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, (uint16_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, (uint16_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, (uint16_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   uint16_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, (uint16_t)0);
 299   assert(rc == MEMCACHED_SUCCESS);
 300
 301   rc= memcached_prepend(memc, key, strlen(key),
 302                        "the ", strlen("the "),
 303                        (time_t)0, (uint16_t)0);
 304   assert(rc == MEMCACHED_SUCCESS);
 305
 306   rc= memcached_prepend(memc, key, strlen(key),
 307                        "we ", strlen("we "),
 308                        (time_t)0, (uint16_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 uint8_t add_test(memcached_st *memc)
 322 {
 323   memcached_return rc;
 324   char *key= "foo";
 325   char *value= "when we sanitize";
 326
 327   rc= memcached_add(memc, key, strlen(key),
 328                     value, strlen(value),
 329                     (time_t)0, (uint16_t)0);
 330   assert(rc == MEMCACHED_NOTSTORED);
 331
 332   return 0;
 333 }
 334
 335 uint8_t replace_test(memcached_st *memc)
 336 {
 337   memcached_return rc;
 338   char *key= "foo";
 339   char *value= "when we sanitize";
 340
 341   rc= memcached_replace(memc, key, strlen(key),
 342                     value, strlen(value),
 343                     (time_t)0, (uint16_t)0);
 344   assert(rc == MEMCACHED_SUCCESS);
 345
 346   return 0;
 347 }
 348
 349 uint8_t delete_test(memcached_st *memc)
 350 {
 351   memcached_return rc;
 352   char *key= "foo";
 353   char *value= "when we sanitize";
 354
 355   rc= memcached_set(memc, key, strlen(key),
 356                     value, strlen(value),
 357                     (time_t)0, (uint16_t)0);
 358   assert(rc == MEMCACHED_SUCCESS);
 359
 360   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 361   assert(rc == MEMCACHED_SUCCESS);
 362
 363   return 0;
 364 }
 365
 366 uint8_t flush_test(memcached_st *memc)
 367 {
 368   memcached_return rc;
 369
 370   rc= memcached_flush(memc, 0);
 371   assert(rc == MEMCACHED_SUCCESS);
 372
 373   return 0;
 374 }
 375
 376 uint8_t get_test(memcached_st *memc)
 377 {
 378   memcached_return rc;
 379   char *key= "foo";
 380   char *string;
 381   size_t string_length;
 382   uint16_t flags;
 383
 384   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 385   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND);
 386
 387   string= memcached_get(memc, key, strlen(key),
 388                         &string_length, &flags, &rc);
 389
 390   assert(rc == MEMCACHED_NOTFOUND);
 391   assert(string_length ==  0);
 392   assert(!string);
 393
 394   return 0;
 395 }
 396
 397 uint8_t get_test2(memcached_st *memc)
 398 {
 399   memcached_return rc;
 400   char *key= "foo";
 401   char *value= "when we sanitize";
 402   char *string;
 403   size_t string_length;
 404   uint16_t flags;
 405
 406   rc= memcached_set(memc, key, strlen(key),
 407                     value, strlen(value),
 408                     (time_t)0, (uint16_t)0);
 409   assert(rc == MEMCACHED_SUCCESS);
 410
 411   string= memcached_get(memc, key, strlen(key),
 412                         &string_length, &flags, &rc);
 413
 414   assert(string);
 415   assert(rc == MEMCACHED_SUCCESS);
 416   assert(string_length == strlen(value));
 417   assert(!memcmp(string, value, string_length));
 418
 419   free(string);
 420
 421   return 0;
 422 }
 423
 424 uint8_t set_test2(memcached_st *memc)
 425 {
 426   memcached_return rc;
 427   char *key= "foo";
 428   char *value= "train in the brain";
 429   size_t value_length= strlen(value);
 430   unsigned int x;
 431
 432   for (x= 0; x < 10; x++)
 433   {
 434     rc= memcached_set(memc, key, strlen(key),
 435                       value, value_length,
 436                       (time_t)0, (uint16_t)0);
 437     assert(rc == MEMCACHED_SUCCESS);
 438   }
 439
 440   return 0;
 441 }
 442
 443 uint8_t set_test3(memcached_st *memc)
 444 {
 445   memcached_return rc;
 446   char *key= "foo";
 447   char *value;
 448   size_t value_length= 8191;
 449   unsigned int x;
 450
 451   value = (char*)malloc(value_length);
 452   assert(value);
 453
 454   for (x= 0; x < value_length; x++)
 455     value[x] = (char) (x % 127);
 456
 457   for (x= 0; x < 1; x++)
 458   {
 459     rc= memcached_set(memc, key, strlen(key),
 460                       value, value_length,
 461                       (time_t)0, (uint16_t)0);
 462     assert(rc == MEMCACHED_SUCCESS);
 463   }
 464
 465   free(value);
 466
 467   return 0;
 468 }
 469
 470 uint8_t get_test3(memcached_st *memc)
 471 {
 472   memcached_return rc;
 473   char *key= "foo";
 474   char *value;
 475   size_t value_length= 8191;
 476   char *string;
 477   size_t string_length;
 478   uint16_t flags;
 479   int x;
 480
 481   value = (char*)malloc(value_length);
 482   assert(value);
 483
 484   for (x= 0; x < value_length; x++)
 485     value[x] = (char) (x % 127);
 486
 487   rc= memcached_set(memc, key, strlen(key),
 488                     value, value_length,
 489                     (time_t)0, (uint16_t)0);
 490   assert(rc == MEMCACHED_SUCCESS);
 491
 492   string= memcached_get(memc, key, strlen(key),
 493                         &string_length, &flags, &rc);
 494
 495   assert(rc == MEMCACHED_SUCCESS);
 496   assert(string);
 497   assert(string_length == value_length);
 498   assert(!memcmp(string, value, string_length));
 499
 500   free(string);
 501   free(value);
 502
 503   return 0;
 504 }
 505
 506 uint8_t get_test4(memcached_st *memc)
 507 {
 508   memcached_return rc;
 509   char *key= "foo";
 510   char *value;
 511   size_t value_length= 8191;
 512   char *string;
 513   size_t string_length;
 514   uint16_t flags;
 515   int x;
 516
 517   value = (char*)malloc(value_length);
 518   assert(value);
 519
 520   for (x= 0; x < value_length; x++)
 521     value[x] = (char) (x % 127);
 522
 523   rc= memcached_set(memc, key, strlen(key),
 524                     value, value_length,
 525                     (time_t)0, (uint16_t)0);
 526   assert(rc == MEMCACHED_SUCCESS);
 527
 528   for (x= 0; x < 10; x++)
 529   {
 530     string= memcached_get(memc, key, strlen(key),
 531                           &string_length, &flags, &rc);
 532
 533     assert(rc == MEMCACHED_SUCCESS);
 534     assert(string);
 535     assert(string_length == value_length);
 536     assert(!memcmp(string, value, string_length));
 537     free(string);
 538   }
 539
 540   free(value);
 541
 542   return 0;
 543 }
 544
 545 /* Do not copy the style of this code, I just access hosts to testthis function */
 546 uint8_t stats_servername_test(memcached_st *memc)
 547 {
 548   memcached_return rc;
 549   memcached_stat_st stat;
 550   rc= memcached_stat_servername(&stat, NULL,
 551                                  memc->hosts[0].hostname,
 552                                  memc->hosts[0].port);
 553
 554   return 0;
 555 }
 556
 557 uint8_t increment_test(memcached_st *memc)
 558 {
 559   uint64_t new_number;
 560   memcached_return rc;
 561   char *key= "number";
 562   char *value= "0";
 563
 564   rc= memcached_set(memc, key, strlen(key),
 565                     value, strlen(value),
 566                     (time_t)0, (uint16_t)0);
 567   assert(rc == MEMCACHED_SUCCESS);
 568
 569   rc= memcached_increment(memc, key, strlen(key),
 570                           1, &new_number);
 571   assert(rc == MEMCACHED_SUCCESS);
 572   assert(new_number == 1);
 573
 574   rc= memcached_increment(memc, key, strlen(key),
 575                           1, &new_number);
 576   assert(rc == MEMCACHED_SUCCESS);
 577   assert(new_number == 2);
 578
 579   return 0;
 580 }
 581
 582 uint8_t decrement_test(memcached_st *memc)
 583 {
 584   uint64_t new_number;
 585   memcached_return rc;
 586   char *key= "number";
 587   char *value= "3";
 588
 589   rc= memcached_set(memc, key, strlen(key),
 590                     value, strlen(value),
 591                     (time_t)0, (uint16_t)0);
 592   assert(rc == MEMCACHED_SUCCESS);
 593
 594   rc= memcached_decrement(memc, key, strlen(key),
 595                           1, &new_number);
 596   assert(rc == MEMCACHED_SUCCESS);
 597   assert(new_number == 2);
 598
 599   rc= memcached_decrement(memc, key, strlen(key),
 600                           1, &new_number);
 601   assert(rc == MEMCACHED_SUCCESS);
 602   assert(new_number == 1);
 603
 604   return 0;
 605 }
 606
 607 uint8_t quit_test(memcached_st *memc)
 608 {
 609   memcached_return rc;
 610   char *key= "fudge";
 611   char *value= "sanford and sun";
 612
 613   rc= memcached_set(memc, key, strlen(key),
 614                     value, strlen(value),
 615                     (time_t)10, (uint16_t)3);
 616   assert(rc == MEMCACHED_SUCCESS);
 617   memcached_quit(memc);
 618
 619   rc= memcached_set(memc, key, strlen(key),
 620                     value, strlen(value),
 621                     (time_t)50, (uint16_t)9);
 622   assert(rc == MEMCACHED_SUCCESS);
 623
 624   return 0;
 625 }
 626
 627 uint8_t mget_result_test(memcached_st *memc)
 628 {
 629   memcached_return rc;
 630   char *keys[]= {"fudge", "son", "food"};
 631   size_t key_length[]= {5, 3, 4};
 632   unsigned int x;
 633
 634   memcached_result_st results_obj;
 635   memcached_result_st *results;
 636
 637   results= memcached_result_create(memc, &results_obj);
 638   assert(results);
 639   assert(&results_obj == results);
 640
 641   /* We need to empty the server before continueing test */
 642   rc= memcached_flush(memc, 0);
 643   assert(rc == MEMCACHED_SUCCESS);
 644
 645   rc= memcached_mget(memc, keys, key_length, 3);
 646   assert(rc == MEMCACHED_SUCCESS);
 647
 648   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 649   {
 650     assert(results);
 651   }
 652
 653   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 654   assert(!results);
 655   assert(rc == MEMCACHED_NOTFOUND);
 656
 657   for (x= 0; x < 3; x++)
 658   {
 659     rc= memcached_set(memc, keys[x], key_length[x],
 660                       keys[x], key_length[x],
 661                       (time_t)50, (uint16_t)9);
 662     assert(rc == MEMCACHED_SUCCESS);
 663   }
 664
 665   rc= memcached_mget(memc, keys, key_length, 3);
 666   assert(rc == MEMCACHED_SUCCESS);
 667
 668   while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
 669   {
 670     assert(results);
 671     assert(&results_obj == results);
 672     assert(rc == MEMCACHED_SUCCESS);
 673     assert(memcached_result_key_length(results) == memcached_result_length(results));
 674     assert(!memcmp(memcached_result_key_value(results),
 675                    memcached_result_value(results),
 676                    memcached_result_length(results)));
 677   }
 678
 679   memcached_result_free(&results_obj);
 680
 681   return 0;
 682 }
 683
 684 uint8_t mget_result_alloc_test(memcached_st *memc)
 685 {
 686   memcached_return rc;
 687   char *keys[]= {"fudge", "son", "food"};
 688   size_t key_length[]= {5, 3, 4};
 689   unsigned int x;
 690
 691   memcached_result_st *results;
 692
 693   /* We need to empty the server before continueing test */
 694   rc= memcached_flush(memc, 0);
 695   assert(rc == MEMCACHED_SUCCESS);
 696
 697   rc= memcached_mget(memc, keys, key_length, 3);
 698   assert(rc == MEMCACHED_SUCCESS);
 699
 700   while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
 701   {
 702     assert(results);
 703   }
 704   assert(!results);
 705   assert(rc == MEMCACHED_NOTFOUND);
 706
 707   for (x= 0; x < 3; x++)
 708   {
 709     rc= memcached_set(memc, keys[x], key_length[x],
 710                       keys[x], key_length[x],
 711                       (time_t)50, (uint16_t)9);
 712     assert(rc == MEMCACHED_SUCCESS);
 713   }
 714
 715   rc= memcached_mget(memc, keys, key_length, 3);
 716   assert(rc == MEMCACHED_SUCCESS);
 717
 718   x= 0;
 719   while ((results= memcached_fetch_result(memc, NULL, &rc)))
 720   {
 721     assert(results);
 722     assert(rc == MEMCACHED_SUCCESS);
 723     assert(memcached_result_key_length(results) == memcached_result_length(results));
 724     assert(!memcmp(memcached_result_key_value(results),
 725                    memcached_result_value(results),
 726                    memcached_result_length(results)));
 727     memcached_result_free(results);
 728     x++;
 729   }
 730
 731   return 0;
 732 }
 733
 734 uint8_t mget_test(memcached_st *memc)
 735 {
 736   memcached_return rc;
 737   char *keys[]= {"fudge", "son", "food"};
 738   size_t key_length[]= {5, 3, 4};
 739   unsigned int x;
 740   uint16_t flags;
 741
 742   char return_key[MEMCACHED_MAX_KEY];
 743   size_t return_key_length;
 744   char *return_value;
 745   size_t return_value_length;
 746
 747   /* We need to empty the server before continueing test */
 748   rc= memcached_flush(memc, 0);
 749   assert(rc == MEMCACHED_SUCCESS);
 750
 751   rc= memcached_mget(memc, keys, key_length, 3);
 752   assert(rc == MEMCACHED_SUCCESS);
 753
 754   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 755                       &return_value_length, &flags, &rc)) != NULL)
 756   {
 757     assert(return_value);
 758   }
 759   assert(!return_value);
 760   assert(return_value_length == 0);
 761   assert(rc == MEMCACHED_NOTFOUND);
 762
 763   for (x= 0; x < 3; x++)
 764   {
 765     rc= memcached_set(memc, keys[x], key_length[x],
 766                       keys[x], key_length[x],
 767                       (time_t)50, (uint16_t)9);
 768     assert(rc == MEMCACHED_SUCCESS);
 769   }
 770
 771   rc= memcached_mget(memc, keys, key_length, 3);
 772   assert(rc == MEMCACHED_SUCCESS);
 773
 774   x= 0;
 775   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 776                                         &return_value_length, &flags, &rc)))
 777   {
 778     assert(return_value);
 779     assert(rc == MEMCACHED_SUCCESS);
 780     assert(return_key_length == return_value_length);
 781     assert(!memcmp(return_value, return_key, return_value_length));
 782     free(return_value);
 783     x++;
 784   }
 785
 786   return 0;
 787 }
 788
 789 uint8_t get_stats_keys(memcached_st *memc)
 790 {
 791  char **list;
 792  char **ptr;
 793  memcached_stat_st stat;
 794  memcached_return rc;
 795
 796  list= memcached_stat_get_keys(memc, &stat, &rc);
 797  assert(rc == MEMCACHED_SUCCESS);
 798  for (ptr= list; *ptr; ptr++)
 799    printf("Found key %s\n", *ptr);
 800  fflush(stdout);
 801
 802  free(list);
 803
 804  return 0;
 805 }
 806
 807 uint8_t get_stats(memcached_st *memc)
 808 {
 809  unsigned int x;
 810  char **list;
 811  char **ptr;
 812  memcached_return rc;
 813  memcached_stat_st *stat;
 814
 815  stat= memcached_stat(memc, NULL, &rc);
 816  assert(rc == MEMCACHED_SUCCESS);
 817
 818  assert(rc == MEMCACHED_SUCCESS);
 819  assert(stat);
 820
 821  for (x= 0; x < memcached_server_count(memc); x++)
 822  {
 823    list= memcached_stat_get_keys(memc, stat+x, &rc);
 824    assert(rc == MEMCACHED_SUCCESS);
 825    for (ptr= list; *ptr; ptr++);
 826
 827    free(list);
 828  }
 829
 830  memcached_stat_free(NULL, stat);
 831
 832   return 0;
 833 }
 834
 835 uint8_t add_host_test(memcached_st *memc)
 836 {
 837   unsigned int x;
 838   memcached_server_st *servers;
 839   memcached_return rc;
 840   char servername[]= "0.example.com";
 841
 842   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 843   assert(servers);
 844   assert(1 == memcached_server_list_count(servers));
 845
 846   for (x= 2; x < 20; x++)
 847   {
 848     char buffer[SMALL_STRING_LEN];
 849
 850     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 851     servers= memcached_server_list_append(servers, buffer, 401,
 852                                      &rc);
 853     assert(rc == MEMCACHED_SUCCESS);
 854     assert(x == memcached_server_list_count(servers));
 855   }
 856
 857   rc= memcached_server_push(memc, servers);
 858   assert(rc == MEMCACHED_SUCCESS);
 859   rc= memcached_server_push(memc, servers);
 860   assert(rc == MEMCACHED_SUCCESS);
 861
 862   memcached_server_list_free(servers);
 863
 864   return 0;
 865 }
 866
 867 /* We don't test the behavior itself, we test the switches */
 868 uint8_t behavior_test(memcached_st *memc)
 869 {
 870   unsigned long long value;
 871   unsigned int set= 1;
 872
 873   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 874   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 875   assert(value == 1);
 876
 877   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 878   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 879   assert(value == 1);
 880
 881   set= MEMCACHED_HASH_MD5;
 882   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
 883   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 884   assert(value == MEMCACHED_HASH_MD5);
 885
 886   set= 0;
 887
 888   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 889   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 890   assert(value == 0);
 891
 892   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 893   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 894   assert(value == 0);
 895
 896   set= MEMCACHED_HASH_DEFAULT;
 897   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
 898   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 899   assert(value == MEMCACHED_HASH_DEFAULT);
 900
 901   set= MEMCACHED_HASH_CRC;
 902   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
 903   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 904   assert(value == MEMCACHED_HASH_CRC);
 905
 906   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
 907   assert(value > 0);
 908
 909   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 910   assert(value > 0);
 911
 912   return 0;
 913 }
 914
 915 /* Test case provided by Cal Haldenbrand */
 916 uint8_t user_supplied_bug1(memcached_st *memc)
 917 {
 918   unsigned int setter= 1;
 919   unsigned int x;
 920
 921   unsigned long long total= 0;
 922   int size= 0;
 923   char key[10];
 924   char randomstuff[6 * 1024];
 925   memcached_return rc;
 926
 927   memset(randomstuff, 0, 6 * 1024);
 928
 929   /* We just keep looking at the same values over and over */
 930   srandom(10);
 931
 932   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 933   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 934
 935
 936   /* add key */
 937   for (x= 0 ; total < 20 * 1024576 ; x++ )
 938   {
 939     unsigned int j= 0;
 940
 941     size= (rand() % ( 5 * 1024 ) ) + 400;
 942     memset(randomstuff, 0, 6 * 1024);
 943     assert(size < 6 * 1024); /* Being safe here */
 944
 945     for (j= 0 ; j < size ;j++)
 946       randomstuff[j] = (char) (rand() % 26) + 97;
 947
 948     total += size;
 949     sprintf(key, "%d", x);
 950     rc = memcached_set(memc, key, strlen(key),
 951                        randomstuff, strlen(randomstuff), 10, 0);
 952     /* If we fail, lets try again */
 953     if (rc != MEMCACHED_SUCCESS)
 954       rc = memcached_set(memc, key, strlen(key),
 955                          randomstuff, strlen(randomstuff), 10, 0);
 956     assert(rc == MEMCACHED_SUCCESS);
 957   }
 958
 959   return 0;
 960 }
 961
 962 /* Test case provided by Cal Haldenbrand */
 963 uint8_t user_supplied_bug2(memcached_st *memc)
 964 {
 965   int errors;
 966   unsigned int setter;
 967   unsigned int x;
 968   unsigned long long total;
 969
 970   setter= 1;
 971   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 972   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 973 #ifdef NOT_YET
 974   setter = 20 * 1024576;
 975   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
 976   setter = 20 * 1024576;
 977   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
 978   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
 979   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 980
 981   for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
 982 #endif
 983
 984   for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
 985   {
 986     memcached_return rc= MEMCACHED_SUCCESS;
 987     char buffer[SMALL_STRING_LEN];
 988     uint16_t flags= 0;
 989     size_t val_len= 0;
 990     char *getval;
 991
 992     memset(buffer, 0, SMALL_STRING_LEN);
 993
 994     snprintf(buffer, SMALL_STRING_LEN, "%u", x);
 995     getval= memcached_get(memc, buffer, strlen(buffer),
 996                            &val_len, &flags, &rc);
 997     if (rc != MEMCACHED_SUCCESS)
 998     {
 999       if (rc == MEMCACHED_NOTFOUND)
1000         errors++;
1001       else
1002         assert(0);
1003
1004       continue;
1005     }
1006     total+= val_len;
1007     errors= 0;
1008     free(getval);
1009   }
1010
1011   return 0;
1012 }
1013
1014 /* Do a large mget() over all the keys we think exist */
1015 #define KEY_COUNT 3000 // * 1024576
1016 uint8_t user_supplied_bug3(memcached_st *memc)
1017 {
1018   memcached_return rc;
1019   unsigned int setter;
1020   unsigned int x;
1021   char **keys;
1022   size_t key_lengths[KEY_COUNT];
1023
1024   setter= 1;
1025   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
1026   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
1027 #ifdef NOT_YET
1028   setter = 20 * 1024576;
1029   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
1030   setter = 20 * 1024576;
1031   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
1032   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1033   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1034 #endif
1035
1036   keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
1037   assert(keys);
1038   memset(keys, 0, (sizeof(char *) * KEY_COUNT));
1039   for (x= 0; x < KEY_COUNT; x++)
1040   {
1041     char buffer[30];
1042
1043     snprintf(buffer, 30, "%u", x);
1044     keys[x]= strdup(buffer);
1045     key_lengths[x]= strlen(keys[x]);
1046   }
1047
1048   rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
1049   assert(rc == MEMCACHED_SUCCESS);
1050
1051   /* Turn this into a help function */
1052   {
1053     char return_key[MEMCACHED_MAX_KEY];
1054     size_t return_key_length;
1055     char *return_value;
1056     size_t return_value_length;
1057     uint16_t flags;
1058
1059     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1060                                           &return_value_length, &flags, &rc)))
1061     {
1062       assert(return_value);
1063       assert(rc == MEMCACHED_SUCCESS);
1064       free(return_value);
1065     }
1066   }
1067
1068   for (x= 0; x < KEY_COUNT; x++)
1069     free(keys[x]);
1070   free(keys);
1071
1072   return 0;
1073 }
1074
1075 /* Make sure we behave properly if server list has no values */
1076 uint8_t user_supplied_bug4(memcached_st *memc)
1077 {
1078   memcached_return rc;
1079   char *keys[]= {"fudge", "son", "food"};
1080   size_t key_length[]= {5, 3, 4};
1081   unsigned int x;
1082   uint16_t flags;
1083
1084   /* Here we free everything before running a bunch of mget tests */
1085   {
1086     memcached_server_list_free(memc->hosts);
1087     memc->hosts= NULL;
1088     memc->number_of_hosts= 0;
1089   }
1090
1091   char return_key[MEMCACHED_MAX_KEY];
1092   size_t return_key_length;
1093   char *return_value;
1094   size_t return_value_length;
1095
1096   /* We need to empty the server before continueing test */
1097   rc= memcached_flush(memc, 0);
1098   assert(rc == MEMCACHED_NO_SERVERS);
1099
1100   rc= memcached_mget(memc, keys, key_length, 3);
1101   assert(rc == MEMCACHED_NO_SERVERS);
1102
1103   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1104                       &return_value_length, &flags, &rc)) != NULL)
1105   {
1106     assert(return_value);
1107   }
1108   assert(!return_value);
1109   assert(return_value_length == 0);
1110   assert(rc == MEMCACHED_NO_SERVERS);
1111
1112   for (x= 0; x < 3; x++)
1113   {
1114     rc= memcached_set(memc, keys[x], key_length[x],
1115                       keys[x], key_length[x],
1116                       (time_t)50, (uint16_t)9);
1117     assert(rc == MEMCACHED_NO_SERVERS);
1118   }
1119
1120   rc= memcached_mget(memc, keys, key_length, 3);
1121   assert(rc == MEMCACHED_NO_SERVERS);
1122
1123   x= 0;
1124   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1125                                         &return_value_length, &flags, &rc)))
1126   {
1127     assert(return_value);
1128     assert(rc == MEMCACHED_SUCCESS);
1129     assert(return_key_length == return_value_length);
1130     assert(!memcmp(return_value, return_key, return_value_length));
1131     free(return_value);
1132     x++;
1133   }
1134
1135   return 0;
1136 }
1137
1138 #define VALUE_SIZE_BUG5 1048064
1139 uint8_t user_supplied_bug5(memcached_st *memc)
1140 {
1141   memcached_return rc;
1142   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1143   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1144   char return_key[MEMCACHED_MAX_KEY];
1145   size_t return_key_length;
1146   char *value;
1147   size_t value_length;
1148   uint16_t flags;
1149   unsigned int count;
1150   unsigned int x;
1151   char insert_data[VALUE_SIZE_BUG5];
1152
1153   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1154     insert_data[x]= rand();
1155
1156   memcached_flush(memc, 0);
1157   value= memcached_get(memc, keys[0], key_length[0],
1158                         &value_length, &flags, &rc);
1159   assert(value == NULL);
1160   rc= memcached_mget(memc, keys, key_length, 4);
1161
1162   count= 0;
1163   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1164                                         &value_length, &flags, &rc)))
1165     count++;
1166   assert(count == 0);
1167
1168   for (x= 0; x < 4; x++)
1169   {
1170     rc= memcached_set(memc, keys[x], key_length[x],
1171                       insert_data, VALUE_SIZE_BUG5,
1172                       (time_t)0, (uint16_t)0);
1173     assert(rc == MEMCACHED_SUCCESS);
1174   }
1175
1176   for (x= 0; x < 10; x++)
1177   {
1178     value= memcached_get(memc, keys[0], key_length[0],
1179                          &value_length, &flags, &rc);
1180     assert(value);
1181     free(value);
1182
1183     rc= memcached_mget(memc, keys, key_length, 4);
1184     count= 0;
1185     while ((value= memcached_fetch(memc, return_key, &return_key_length,
1186                                           &value_length, &flags, &rc)))
1187     {
1188       count++;
1189       free(value);
1190     }
1191     assert(count == 4);
1192   }
1193
1194   return 0;
1195 }
1196
1197 uint8_t user_supplied_bug6(memcached_st *memc)
1198 {
1199   memcached_return rc;
1200   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1201   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1202   char return_key[MEMCACHED_MAX_KEY];
1203   size_t return_key_length;
1204   char *value;
1205   size_t value_length;
1206   uint16_t flags;
1207   unsigned int count;
1208   unsigned int x;
1209   char insert_data[VALUE_SIZE_BUG5];
1210
1211   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1212     insert_data[x]= rand();
1213
1214   memcached_flush(memc, 0);
1215   value= memcached_get(memc, keys[0], key_length[0],
1216                         &value_length, &flags, &rc);
1217   assert(value == NULL);
1218   rc= memcached_mget(memc, keys, key_length, 4);
1219
1220   count= 0;
1221   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1222                                         &value_length, &flags, &rc)))
1223     count++;
1224   assert(count == 0);
1225
1226   for (x= 0; x < 4; x++)
1227   {
1228     rc= memcached_set(memc, keys[x], key_length[x],
1229                       insert_data, VALUE_SIZE_BUG5,
1230                       (time_t)0, (uint16_t)0);
1231     assert(rc == MEMCACHED_SUCCESS);
1232   }
1233
1234   for (x= 0; x < 10; x++)
1235   {
1236     value= memcached_get(memc, keys[0], key_length[0],
1237                          &value_length, &flags, &rc);
1238     assert(value);
1239     free(value);
1240
1241     rc= memcached_mget(memc, keys, key_length, 4);
1242     count= 3;
1243     /* We test for purge of partial complete fetches */
1244     for (count= 3; count; count--)
1245     {
1246       value= memcached_fetch(memc, return_key, &return_key_length,
1247                              &value_length, &flags, &rc);
1248       free(value);
1249       assert(rc == MEMCACHED_SUCCESS);
1250     }
1251   }
1252
1253   return 0;
1254 }
1255
1256 uint8_t user_supplied_bug8(memcached_st *memc)
1257 {
1258   memcached_return rc;
1259   memcached_st *mine;
1260   memcached_st *clone;
1261
1262   memcached_server_st *servers;
1263   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";
1264
1265   servers= memcached_servers_parse(server_list);
1266   assert(servers);
1267
1268   mine= memcached_create(NULL);
1269   rc= memcached_server_push(mine, servers);
1270   assert(rc == MEMCACHED_SUCCESS);
1271   memcached_server_list_free(servers);
1272
1273   assert(mine);
1274   clone= memcached_clone(NULL, mine);
1275
1276   memcached_quit(mine);
1277   memcached_quit(clone);
1278
1279
1280   memcached_free(mine);
1281   memcached_free(clone);
1282
1283   return 0;
1284 }
1285
1286 /* Test flag store/retrieve */
1287 uint8_t user_supplied_bug7(memcached_st *memc)
1288 {
1289   memcached_return rc;
1290   char *keys= "036790384900";
1291   size_t key_length=  strlen("036790384900");
1292   char return_key[MEMCACHED_MAX_KEY];
1293   size_t return_key_length;
1294   char *value;
1295   size_t value_length;
1296   uint16_t flags;
1297   unsigned int x;
1298   char insert_data[VALUE_SIZE_BUG5];
1299
1300   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1301     insert_data[x]= rand();
1302
1303   memcached_flush(memc, 0);
1304
1305   flags= 245;
1306   rc= memcached_set(memc, keys, key_length,
1307                     insert_data, VALUE_SIZE_BUG5,
1308                     (time_t)0, flags);
1309   assert(rc == MEMCACHED_SUCCESS);
1310
1311   flags= 0;
1312   value= memcached_get(memc, keys, key_length,
1313                         &value_length, &flags, &rc);
1314   assert(flags == 245);
1315   assert(value);
1316   free(value);
1317
1318   rc= memcached_mget(memc, &keys, &key_length, 1);
1319
1320   flags= 0;
1321   value= memcached_fetch(memc, return_key, &return_key_length,
1322                          &value_length, &flags, &rc);
1323   assert(flags == 245);
1324   assert(value);
1325   free(value);
1326
1327
1328   return 0;
1329 }
1330
1331 uint8_t result_static(memcached_st *memc)
1332 {
1333   memcached_result_st result;
1334   memcached_result_st *result_ptr;
1335
1336   result_ptr= memcached_result_create(memc, &result);
1337   assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
1338   assert(result_ptr);
1339   memcached_result_free(&result);
1340
1341   return 0;
1342 }
1343
1344 uint8_t result_alloc(memcached_st *memc)
1345 {
1346   memcached_result_st *result;
1347
1348   result= memcached_result_create(memc, NULL);
1349   assert(result);
1350   memcached_result_free(result);
1351
1352   return 0;
1353 }
1354
1355 uint8_t string_static_null(memcached_st *memc)
1356 {
1357   memcached_string_st string;
1358   memcached_string_st *string_ptr;
1359
1360   string_ptr= memcached_string_create(memc, &string, 0);
1361   assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
1362   assert(string_ptr);
1363   memcached_string_free(&string);
1364
1365   return 0;
1366 }
1367
1368 uint8_t string_alloc_null(memcached_st *memc)
1369 {
1370   memcached_string_st *string;
1371
1372   string= memcached_string_create(memc, NULL, 0);
1373   assert(string);
1374   memcached_string_free(string);
1375
1376   return 0;
1377 }
1378
1379 uint8_t string_alloc_with_size(memcached_st *memc)
1380 {
1381   memcached_string_st *string;
1382
1383   string= memcached_string_create(memc, NULL, 1024);
1384   assert(string);
1385   memcached_string_free(string);
1386
1387   return 0;
1388 }
1389
1390 uint8_t string_alloc_with_size_toobig(memcached_st *memc)
1391 {
1392   memcached_string_st *string;
1393
1394   string= memcached_string_create(memc, NULL, INT64_MAX);
1395   assert(string == NULL);
1396
1397   return 0;
1398 }
1399
1400 uint8_t string_alloc_append(memcached_st *memc)
1401 {
1402   unsigned int x;
1403   char buffer[SMALL_STRING_LEN];
1404   memcached_string_st *string;
1405
1406   /* Ring the bell! */
1407   memset(buffer, 6, SMALL_STRING_LEN);
1408
1409   string= memcached_string_create(memc, NULL, 100);
1410   assert(string);
1411
1412   for (x= 0; x < 1024; x++)
1413   {
1414     memcached_return rc;
1415     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1416     assert(rc == MEMCACHED_SUCCESS);
1417   }
1418   memcached_string_free(string);
1419
1420   return 0;
1421 }
1422
1423 uint8_t string_alloc_append_toobig(memcached_st *memc)
1424 {
1425   memcached_return rc;
1426   unsigned int x;
1427   char buffer[SMALL_STRING_LEN];
1428   memcached_string_st *string;
1429
1430   /* Ring the bell! */
1431   memset(buffer, 6, SMALL_STRING_LEN);
1432
1433   string= memcached_string_create(memc, NULL, 100);
1434   assert(string);
1435
1436   for (x= 0; x < 1024; x++)
1437   {
1438     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1439     assert(rc == MEMCACHED_SUCCESS);
1440   }
1441   rc= memcached_string_append(string, buffer, INT64_MAX);
1442   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
1443   memcached_string_free(string);
1444
1445   return 0;
1446 }
1447
1448 uint8_t cleanup_pairs(memcached_st *memc)
1449 {
1450   pairs_free(global_pairs);
1451
1452   return 0;
1453 }
1454
1455 uint8_t generate_data(memcached_st *memc)
1456 {
1457   unsigned long long x;
1458   global_pairs= pairs_generate(GLOBAL_COUNT);
1459   execute_set(memc, global_pairs, GLOBAL_COUNT);
1460
1461   for (x= 0; x < GLOBAL_COUNT; x++)
1462   {
1463     global_keys[x]= global_pairs[x].key;
1464     global_keys_length[x]=  global_pairs[x].key_length;
1465   }
1466
1467   return 0;
1468 }
1469
1470 uint8_t get_read(memcached_st *memc)
1471 {
1472   unsigned int x;
1473   memcached_return rc;
1474
1475   {
1476     char *return_value;
1477     size_t return_value_length;
1478     uint16_t flags;
1479
1480     for (x= 0; x < GLOBAL_COUNT; x++)
1481     {
1482       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
1483                                   &return_value_length, &flags, &rc);
1484       /*
1485       assert(return_value);
1486       assert(rc == MEMCACHED_SUCCESS);
1487     */
1488       if (rc == MEMCACHED_SUCCESS && return_value)
1489         free(return_value);
1490     }
1491   }
1492
1493   return 0;
1494 }
1495
1496 uint8_t mget_read(memcached_st *memc)
1497 {
1498   memcached_return rc;
1499
1500   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1501   assert(rc == MEMCACHED_SUCCESS);
1502   /* Turn this into a help function */
1503   {
1504     char return_key[MEMCACHED_MAX_KEY];
1505     size_t return_key_length;
1506     char *return_value;
1507     size_t return_value_length;
1508     uint16_t flags;
1509
1510     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1511                                           &return_value_length, &flags, &rc)))
1512     {
1513       assert(return_value);
1514       assert(rc == MEMCACHED_SUCCESS);
1515       free(return_value);
1516     }
1517   }
1518
1519   return 0;
1520 }
1521
1522 uint8_t mget_read_result(memcached_st *memc)
1523 {
1524   memcached_return rc;
1525
1526   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1527   assert(rc == MEMCACHED_SUCCESS);
1528   /* Turn this into a help function */
1529   {
1530     memcached_result_st results_obj;
1531     memcached_result_st *results;
1532
1533     results= memcached_result_create(memc, &results_obj);
1534
1535     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1536     {
1537       assert(results);
1538       assert(rc == MEMCACHED_SUCCESS);
1539     }
1540
1541     memcached_result_free(&results_obj);
1542   }
1543
1544   return 0;
1545 }
1546
1547 uint8_t free_data(memcached_st *memc)
1548 {
1549   pairs_free(global_pairs);
1550
1551   return 0;
1552 }
1553
1554 uint8_t add_host_test1(memcached_st *memc)
1555 {
1556   unsigned int x;
1557   memcached_return rc;
1558   char servername[]= "0.example.com";
1559   memcached_server_st *servers;
1560
1561   servers= memcached_server_list_append(NULL, servername, 400, &rc);
1562   assert(servers);
1563   assert(1 == memcached_server_list_count(servers));
1564
1565   for (x= 2; x < 20; x++)
1566   {
1567     char buffer[SMALL_STRING_LEN];
1568
1569     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1570     servers= memcached_server_list_append(servers, buffer, 401,
1571                                      &rc);
1572     assert(rc == MEMCACHED_SUCCESS);
1573     assert(x == memcached_server_list_count(servers));
1574   }
1575
1576   rc= memcached_server_push(memc, servers);
1577   assert(rc == MEMCACHED_SUCCESS);
1578   rc= memcached_server_push(memc, servers);
1579   assert(rc == MEMCACHED_SUCCESS);
1580
1581   memcached_server_list_free(servers);
1582
1583   return 0;
1584 }
1585
1586 memcached_return pre_nonblock(memcached_st *memc)
1587 {
1588   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1589
1590   return MEMCACHED_SUCCESS;
1591 }
1592
1593 memcached_return pre_md5(memcached_st *memc)
1594 {
1595   memcached_hash value= MEMCACHED_HASH_MD5;
1596   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1597
1598   return MEMCACHED_SUCCESS;
1599 }
1600
1601 memcached_return pre_crc(memcached_st *memc)
1602 {
1603   memcached_hash value= MEMCACHED_HASH_CRC;
1604   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1605
1606   return MEMCACHED_SUCCESS;
1607 }
1608
1609 memcached_return pre_hsieh(memcached_st *memc)
1610 {
1611   memcached_hash value= MEMCACHED_HASH_HSIEH;
1612   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1613
1614   return MEMCACHED_SUCCESS;
1615 }
1616
1617 memcached_return pre_hash_fnv1_64(memcached_st *memc)
1618 {
1619   memcached_hash value= MEMCACHED_HASH_FNV1_64;
1620   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1621
1622   return MEMCACHED_SUCCESS;
1623 }
1624
1625 memcached_return pre_hash_fnv1a_64(memcached_st *memc)
1626 {
1627   memcached_hash value= MEMCACHED_HASH_FNV1A_64;
1628   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1629
1630   return MEMCACHED_SUCCESS;
1631 }
1632
1633 memcached_return pre_hash_fnv1_32(memcached_st *memc)
1634 {
1635   memcached_hash value= MEMCACHED_HASH_FNV1_32;
1636   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1637
1638   return MEMCACHED_SUCCESS;
1639 }
1640
1641 memcached_return pre_hash_fnv1a_32(memcached_st *memc)
1642 {
1643   memcached_hash value= MEMCACHED_HASH_FNV1A_32;
1644   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1645
1646   return MEMCACHED_SUCCESS;
1647 }
1648
1649 memcached_return pre_hash_ketama(memcached_st *memc)
1650 {
1651   memcached_hash value= MEMCACHED_HASH_KETAMA;
1652   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1653
1654   return MEMCACHED_SUCCESS;
1655 }
1656
1657 memcached_return enable_cas(memcached_st *memc)
1658 {
1659   unsigned int set= 1;
1660
1661   memcached_version(memc);
1662
1663   if (memc->hosts[0].major_version >= 1 &&
1664       memc->hosts[0].minor_version >= 2 &&
1665       memc->hosts[0].micro_version >= 4)
1666   {
1667     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
1668
1669     return MEMCACHED_SUCCESS;
1670   }
1671
1672   return MEMCACHED_FAILURE;
1673 }
1674
1675 memcached_return check_for_1_2_3(memcached_st *memc)
1676 {
1677   memcached_version(memc);
1678
1679   if (memc->hosts[0].major_version >= 1 &&
1680       memc->hosts[0].minor_version >= 2 &&
1681       memc->hosts[0].micro_version >= 4)
1682     return MEMCACHED_SUCCESS;
1683
1684   return MEMCACHED_FAILURE;
1685 }
1686
1687 memcached_return pre_unix_socket(memcached_st *memc)
1688 {
1689   memcached_return rc;
1690   struct stat buf;
1691
1692   memcached_server_list_free(memc->hosts);
1693   memc->hosts= NULL;
1694   memc->number_of_hosts= 0;
1695
1696   if (stat("/tmp/memcached.socket", &buf))
1697     return MEMCACHED_FAILURE;
1698
1699   rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");
1700
1701   return rc;
1702 }
1703
1704 memcached_return pre_udp(memcached_st *memc)
1705 {
1706   memcached_return rc;
1707
1708   memcached_server_list_free(memc->hosts);
1709   memc->hosts= NULL;
1710   memc->number_of_hosts= 0;
1711
1712   if (0)
1713     return MEMCACHED_FAILURE;
1714
1715   rc= memcached_server_add_udp(memc, "localhost", MEMCACHED_DEFAULT_PORT);
1716
1717   return rc;
1718 }
1719
1720 memcached_return pre_nodelay(memcached_st *memc)
1721 {
1722   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1723   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
1724
1725   return MEMCACHED_SUCCESS;
1726 }
1727
1728 memcached_return poll_timeout(memcached_st *memc)
1729 {
1730   int32_t timeout;
1731
1732   timeout= 100;
1733
1734   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
1735
1736   timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
1737
1738   assert(timeout == 100);
1739
1740   return MEMCACHED_SUCCESS;
1741 }
1742
1743
1744 /* Clean the server before beginning testing */
1745 test_st tests[] ={
1746   {"flush", 0, flush_test },
1747   {"init", 0, init_test },
1748   {"allocation", 0, allocation_test },
1749   {"clone_test", 0, clone_test },
1750   {"error", 0, error_test },
1751   {"set", 0, set_test },
1752   {"set2", 0, set_test2 },
1753   {"set3", 0, set_test3 },
1754   {"add", 0, add_test },
1755   {"replace", 0, replace_test },
1756   {"delete", 1, delete_test },
1757   {"get", 1, get_test },
1758   {"get2", 0, get_test2 },
1759   {"get3", 0, get_test3 },
1760   {"get4", 0, get_test4 },
1761   {"stats_servername", 0, stats_servername_test },
1762   {"increment", 0, increment_test },
1763   {"decrement", 0, decrement_test },
1764   {"quit", 0, quit_test },
1765   {"mget", 1, mget_test },
1766   {"mget_result", 1, mget_result_test },
1767   {"mget_result_alloc", 1, mget_result_alloc_test },
1768   {"get_stats", 0, get_stats },
1769   {"add_host_test", 0, add_host_test },
1770   {"get_stats_keys", 0, get_stats_keys },
1771   {"behavior_test", 0, get_stats_keys },
1772   {0, 0, 0}
1773 };
1774
1775 test_st string_tests[] ={
1776   {"string static with null", 0, string_static_null },
1777   {"string alloc with null", 0, string_alloc_null },
1778   {"string alloc with 1K", 0, string_alloc_with_size },
1779   {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
1780   {"string append", 0, string_alloc_append },
1781   {"string append failure (too big)", 0, string_alloc_append_toobig },
1782   {0, 0, 0}
1783 };
1784
1785 test_st result_tests[] ={
1786   {"result static", 0, result_static},
1787   {"result alloc", 0, result_alloc},
1788   {0, 0, 0}
1789 };
1790
1791 test_st version_1_2_3[] ={
1792   {"append", 0, append_test },
1793   {"prepend", 0, prepend_test },
1794   {"cas", 0, cas_test },
1795   {"cas2", 0, cas2_test },
1796   {"append_binary", 0, append_binary_test },
1797   {0, 0, 0}
1798 };
1799
1800 test_st user_tests[] ={
1801   {"user_supplied_bug1", 0, user_supplied_bug1 },
1802   {"user_supplied_bug2", 0, user_supplied_bug2 },
1803   {"user_supplied_bug3", 0, user_supplied_bug3 },
1804   {"user_supplied_bug4", 0, user_supplied_bug4 },
1805   {"user_supplied_bug5", 1, user_supplied_bug5 },
1806   {"user_supplied_bug6", 1, user_supplied_bug6 },
1807   {"user_supplied_bug7", 1, user_supplied_bug7 },
1808   {"user_supplied_bug8", 1, user_supplied_bug8 },
1809   {0, 0, 0}
1810 };
1811
1812 test_st generate_tests[] ={
1813   {"generate_data", 0, generate_data },
1814   {"get_read", 0, get_read },
1815   {"mget_read", 0, mget_read },
1816   {"mget_read_result", 0, mget_read_result },
1817   {"cleanup", 0, cleanup_pairs },
1818   {0, 0, 0}
1819 };
1820
1821
1822 collection_st collection[] ={
1823   {"block", 0, 0, tests},
1824   {"nonblock", pre_nonblock, 0, tests},
1825   {"nodelay", pre_nodelay, 0, tests},
1826   {"md5", pre_md5, 0, tests},
1827   {"crc", pre_crc, 0, tests},
1828   {"hsieh", pre_hsieh, 0, tests},
1829   {"fnv1_64", pre_hash_fnv1_64, 0, tests},
1830   {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
1831   {"fnv1_32", pre_hash_fnv1_32, 0, tests},
1832   {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
1833   {"ketama", pre_hash_ketama, 0, tests},
1834   {"unix_socket", pre_unix_socket, 0, tests},
1835   {"unix_socket_nodelay", pre_nodelay, 0, tests},
1836   {"poll_timeout", poll_timeout, 0, tests},
1837   {"gets", enable_cas, 0, tests},
1838 //  {"udp", pre_udp, 0, tests},
1839   {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
1840   {"string", 0, 0, string_tests},
1841   {"result", 0, 0, result_tests},
1842   {"user", 0, 0, user_tests},
1843   {"generate", 0, 0, generate_tests},
1844   {"generate_hsieh", pre_hsieh, 0, generate_tests},
1845   {"generate_nonblock", pre_nonblock, 0, generate_tests},
1846   {0, 0, 0, 0}
1847 };
1848
1849 collection_st *gets_collections(void)
1850 {
1851   return collection;
1852 }