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 /* Test flag store/retrieve */
1257 uint8_t user_supplied_bug7(memcached_st *memc)
1258 {
1259   memcached_return rc;
1260   char *keys= "036790384900";
1261   size_t key_length=  strlen("036790384900");
1262   char return_key[MEMCACHED_MAX_KEY];
1263   size_t return_key_length;
1264   char *value;
1265   size_t value_length;
1266   uint16_t flags;
1267   unsigned int x;
1268   char insert_data[VALUE_SIZE_BUG5];
1269
1270   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1271     insert_data[x]= rand();
1272
1273   memcached_flush(memc, 0);
1274
1275   flags= 245;
1276   rc= memcached_set(memc, keys, key_length,
1277                     insert_data, VALUE_SIZE_BUG5,
1278                     (time_t)0, flags);
1279   assert(rc == MEMCACHED_SUCCESS);
1280
1281   flags= 0;
1282   value= memcached_get(memc, keys, key_length,
1283                         &value_length, &flags, &rc);
1284   assert(flags == 245);
1285   assert(value);
1286   free(value);
1287
1288   rc= memcached_mget(memc, &keys, &key_length, 1);
1289
1290   flags= 0;
1291   value= memcached_fetch(memc, return_key, &return_key_length,
1292                          &value_length, &flags, &rc);
1293   assert(flags == 245);
1294   assert(value);
1295   free(value);
1296
1297
1298   return 0;
1299 }
1300
1301 uint8_t result_static(memcached_st *memc)
1302 {
1303   memcached_result_st result;
1304   memcached_result_st *result_ptr;
1305
1306   result_ptr= memcached_result_create(memc, &result);
1307   assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
1308   assert(result_ptr);
1309   memcached_result_free(&result);
1310
1311   return 0;
1312 }
1313
1314 uint8_t result_alloc(memcached_st *memc)
1315 {
1316   memcached_result_st *result;
1317
1318   result= memcached_result_create(memc, NULL);
1319   assert(result);
1320   memcached_result_free(result);
1321
1322   return 0;
1323 }
1324
1325 uint8_t string_static_null(memcached_st *memc)
1326 {
1327   memcached_string_st string;
1328   memcached_string_st *string_ptr;
1329
1330   string_ptr= memcached_string_create(memc, &string, 0);
1331   assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
1332   assert(string_ptr);
1333   memcached_string_free(&string);
1334
1335   return 0;
1336 }
1337
1338 uint8_t string_alloc_null(memcached_st *memc)
1339 {
1340   memcached_string_st *string;
1341
1342   string= memcached_string_create(memc, NULL, 0);
1343   assert(string);
1344   memcached_string_free(string);
1345
1346   return 0;
1347 }
1348
1349 uint8_t string_alloc_with_size(memcached_st *memc)
1350 {
1351   memcached_string_st *string;
1352
1353   string= memcached_string_create(memc, NULL, 1024);
1354   assert(string);
1355   memcached_string_free(string);
1356
1357   return 0;
1358 }
1359
1360 uint8_t string_alloc_with_size_toobig(memcached_st *memc)
1361 {
1362   memcached_string_st *string;
1363
1364   string= memcached_string_create(memc, NULL, INT64_MAX);
1365   assert(string == NULL);
1366
1367   return 0;
1368 }
1369
1370 uint8_t string_alloc_append(memcached_st *memc)
1371 {
1372   unsigned int x;
1373   char buffer[SMALL_STRING_LEN];
1374   memcached_string_st *string;
1375
1376   /* Ring the bell! */
1377   memset(buffer, 6, SMALL_STRING_LEN);
1378
1379   string= memcached_string_create(memc, NULL, 100);
1380   assert(string);
1381
1382   for (x= 0; x < 1024; x++)
1383   {
1384     memcached_return rc;
1385     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1386     assert(rc == MEMCACHED_SUCCESS);
1387   }
1388   memcached_string_free(string);
1389
1390   return 0;
1391 }
1392
1393 uint8_t string_alloc_append_toobig(memcached_st *memc)
1394 {
1395   memcached_return rc;
1396   unsigned int x;
1397   char buffer[SMALL_STRING_LEN];
1398   memcached_string_st *string;
1399
1400   /* Ring the bell! */
1401   memset(buffer, 6, SMALL_STRING_LEN);
1402
1403   string= memcached_string_create(memc, NULL, 100);
1404   assert(string);
1405
1406   for (x= 0; x < 1024; x++)
1407   {
1408     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1409     assert(rc == MEMCACHED_SUCCESS);
1410   }
1411   rc= memcached_string_append(string, buffer, INT64_MAX);
1412   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
1413   memcached_string_free(string);
1414
1415   return 0;
1416 }
1417
1418 uint8_t cleanup_pairs(memcached_st *memc)
1419 {
1420   pairs_free(global_pairs);
1421
1422   return 0;
1423 }
1424
1425 uint8_t generate_data(memcached_st *memc)
1426 {
1427   unsigned long long x;
1428   global_pairs= pairs_generate(GLOBAL_COUNT);
1429   execute_set(memc, global_pairs, GLOBAL_COUNT);
1430
1431   for (x= 0; x < GLOBAL_COUNT; x++)
1432   {
1433     global_keys[x]= global_pairs[x].key;
1434     global_keys_length[x]=  global_pairs[x].key_length;
1435   }
1436
1437   return 0;
1438 }
1439
1440 uint8_t get_read(memcached_st *memc)
1441 {
1442   unsigned int x;
1443   memcached_return rc;
1444
1445   {
1446     char *return_value;
1447     size_t return_value_length;
1448     uint16_t flags;
1449
1450     for (x= 0; x < GLOBAL_COUNT; x++)
1451     {
1452       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
1453                                   &return_value_length, &flags, &rc);
1454       /*
1455       assert(return_value);
1456       assert(rc == MEMCACHED_SUCCESS);
1457     */
1458       if (rc == MEMCACHED_SUCCESS && return_value)
1459         free(return_value);
1460     }
1461   }
1462
1463   return 0;
1464 }
1465
1466 uint8_t mget_read(memcached_st *memc)
1467 {
1468   memcached_return rc;
1469
1470   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1471   assert(rc == MEMCACHED_SUCCESS);
1472   /* Turn this into a help function */
1473   {
1474     char return_key[MEMCACHED_MAX_KEY];
1475     size_t return_key_length;
1476     char *return_value;
1477     size_t return_value_length;
1478     uint16_t flags;
1479
1480     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1481                                           &return_value_length, &flags, &rc)))
1482     {
1483       assert(return_value);
1484       assert(rc == MEMCACHED_SUCCESS);
1485       free(return_value);
1486     }
1487   }
1488
1489   return 0;
1490 }
1491
1492 uint8_t mget_read_result(memcached_st *memc)
1493 {
1494   memcached_return rc;
1495
1496   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1497   assert(rc == MEMCACHED_SUCCESS);
1498   /* Turn this into a help function */
1499   {
1500     memcached_result_st results_obj;
1501     memcached_result_st *results;
1502
1503     results= memcached_result_create(memc, &results_obj);
1504
1505     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1506     {
1507       assert(results);
1508       assert(rc == MEMCACHED_SUCCESS);
1509     }
1510
1511     memcached_result_free(&results_obj);
1512   }
1513
1514   return 0;
1515 }
1516
1517 uint8_t free_data(memcached_st *memc)
1518 {
1519   pairs_free(global_pairs);
1520
1521   return 0;
1522 }
1523
1524 uint8_t add_host_test1(memcached_st *memc)
1525 {
1526   unsigned int x;
1527   memcached_return rc;
1528   char servername[]= "0.example.com";
1529   memcached_server_st *servers;
1530
1531   servers= memcached_server_list_append(NULL, servername, 400, &rc);
1532   assert(servers);
1533   assert(1 == memcached_server_list_count(servers));
1534
1535   for (x= 2; x < 20; x++)
1536   {
1537     char buffer[SMALL_STRING_LEN];
1538
1539     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1540     servers= memcached_server_list_append(servers, buffer, 401,
1541                                      &rc);
1542     assert(rc == MEMCACHED_SUCCESS);
1543     assert(x == memcached_server_list_count(servers));
1544   }
1545
1546   rc= memcached_server_push(memc, servers);
1547   assert(rc == MEMCACHED_SUCCESS);
1548   rc= memcached_server_push(memc, servers);
1549   assert(rc == MEMCACHED_SUCCESS);
1550
1551   memcached_server_list_free(servers);
1552
1553   return 0;
1554 }
1555
1556 memcached_return pre_nonblock(memcached_st *memc)
1557 {
1558   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1559
1560   return MEMCACHED_SUCCESS;
1561 }
1562
1563 memcached_return pre_md5(memcached_st *memc)
1564 {
1565   memcached_hash value= MEMCACHED_HASH_MD5;
1566   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1567
1568   return MEMCACHED_SUCCESS;
1569 }
1570
1571 memcached_return pre_crc(memcached_st *memc)
1572 {
1573   memcached_hash value= MEMCACHED_HASH_CRC;
1574   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1575
1576   return MEMCACHED_SUCCESS;
1577 }
1578
1579 memcached_return pre_hsieh(memcached_st *memc)
1580 {
1581   memcached_hash value= MEMCACHED_HASH_HSIEH;
1582   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1583
1584   return MEMCACHED_SUCCESS;
1585 }
1586
1587 memcached_return pre_hash_fnv1_64(memcached_st *memc)
1588 {
1589   memcached_hash value= MEMCACHED_HASH_FNV1_64;
1590   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1591
1592   return MEMCACHED_SUCCESS;
1593 }
1594
1595 memcached_return pre_hash_fnv1a_64(memcached_st *memc)
1596 {
1597   memcached_hash value= MEMCACHED_HASH_FNV1A_64;
1598   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1599
1600   return MEMCACHED_SUCCESS;
1601 }
1602
1603 memcached_return pre_hash_fnv1_32(memcached_st *memc)
1604 {
1605   memcached_hash value= MEMCACHED_HASH_FNV1_32;
1606   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1607
1608   return MEMCACHED_SUCCESS;
1609 }
1610
1611 memcached_return pre_hash_fnv1a_32(memcached_st *memc)
1612 {
1613   memcached_hash value= MEMCACHED_HASH_FNV1A_32;
1614   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1615
1616   return MEMCACHED_SUCCESS;
1617 }
1618
1619 memcached_return pre_hash_ketama(memcached_st *memc)
1620 {
1621   memcached_hash value= MEMCACHED_HASH_KETAMA;
1622   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1623
1624   return MEMCACHED_SUCCESS;
1625 }
1626
1627 memcached_return enable_cas(memcached_st *memc)
1628 {
1629   unsigned int set= 1;
1630
1631   memcached_version(memc);
1632
1633   if (memc->hosts[0].major_version >= 1 &&
1634       memc->hosts[0].minor_version >= 2 &&
1635       memc->hosts[0].micro_version >= 4)
1636   {
1637     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
1638
1639     return MEMCACHED_SUCCESS;
1640   }
1641
1642   return MEMCACHED_FAILURE;
1643 }
1644
1645 memcached_return check_for_1_2_3(memcached_st *memc)
1646 {
1647   memcached_version(memc);
1648
1649   if (memc->hosts[0].major_version >= 1 &&
1650       memc->hosts[0].minor_version >= 2 &&
1651       memc->hosts[0].micro_version >= 4)
1652     return MEMCACHED_SUCCESS;
1653
1654   return MEMCACHED_FAILURE;
1655 }
1656
1657 memcached_return pre_unix_socket(memcached_st *memc)
1658 {
1659   memcached_return rc;
1660   struct stat buf;
1661
1662   memcached_server_list_free(memc->hosts);
1663   memc->hosts= NULL;
1664   memc->number_of_hosts= 0;
1665
1666   if (stat("/tmp/memcached.socket", &buf))
1667     return MEMCACHED_FAILURE;
1668
1669   rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");
1670
1671   return rc;
1672 }
1673
1674 memcached_return pre_udp(memcached_st *memc)
1675 {
1676   memcached_return rc;
1677
1678   memcached_server_list_free(memc->hosts);
1679   memc->hosts= NULL;
1680   memc->number_of_hosts= 0;
1681
1682   if (0)
1683     return MEMCACHED_FAILURE;
1684
1685   rc= memcached_server_add_udp(memc, "localhost", MEMCACHED_DEFAULT_PORT);
1686
1687   return rc;
1688 }
1689
1690 memcached_return pre_nodelay(memcached_st *memc)
1691 {
1692   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1693   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
1694
1695   return MEMCACHED_SUCCESS;
1696 }
1697
1698 memcached_return poll_timeout(memcached_st *memc)
1699 {
1700   int32_t timeout;
1701
1702   timeout= 100;
1703
1704   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
1705
1706   timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
1707
1708   assert(timeout == 100);
1709
1710   return MEMCACHED_SUCCESS;
1711 }
1712
1713
1714 /* Clean the server before beginning testing */
1715 test_st tests[] ={
1716   {"flush", 0, flush_test },
1717   {"init", 0, init_test },
1718   {"allocation", 0, allocation_test },
1719   {"clone_test", 0, clone_test },
1720   {"error", 0, error_test },
1721   {"set", 0, set_test },
1722   {"set2", 0, set_test2 },
1723   {"set3", 0, set_test3 },
1724   {"add", 0, add_test },
1725   {"replace", 0, replace_test },
1726   {"delete", 1, delete_test },
1727   {"get", 1, get_test },
1728   {"get2", 0, get_test2 },
1729   {"get3", 0, get_test3 },
1730   {"get4", 0, get_test4 },
1731   {"stats_servername", 0, stats_servername_test },
1732   {"increment", 0, increment_test },
1733   {"decrement", 0, decrement_test },
1734   {"quit", 0, quit_test },
1735   {"mget", 1, mget_test },
1736   {"mget_result", 1, mget_result_test },
1737   {"mget_result_alloc", 1, mget_result_alloc_test },
1738   {"get_stats", 0, get_stats },
1739   {"add_host_test", 0, add_host_test },
1740   {"get_stats_keys", 0, get_stats_keys },
1741   {"behavior_test", 0, get_stats_keys },
1742   {0, 0, 0}
1743 };
1744
1745 test_st string_tests[] ={
1746   {"string static with null", 0, string_static_null },
1747   {"string alloc with null", 0, string_alloc_null },
1748   {"string alloc with 1K", 0, string_alloc_with_size },
1749   {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
1750   {"string append", 0, string_alloc_append },
1751   {"string append failure (too big)", 0, string_alloc_append_toobig },
1752   {0, 0, 0}
1753 };
1754
1755 test_st result_tests[] ={
1756   {"result static", 0, result_static},
1757   {"result alloc", 0, result_alloc},
1758   {0, 0, 0}
1759 };
1760
1761 test_st version_1_2_3[] ={
1762   {"append", 0, append_test },
1763   {"prepend", 0, prepend_test },
1764   {"cas", 0, cas_test },
1765   {"cas2", 0, cas2_test },
1766   {"append_binary", 0, append_binary_test },
1767   {0, 0, 0}
1768 };
1769
1770 test_st user_tests[] ={
1771   {"user_supplied_bug1", 0, user_supplied_bug1 },
1772   {"user_supplied_bug2", 0, user_supplied_bug2 },
1773   {"user_supplied_bug3", 0, user_supplied_bug3 },
1774   {"user_supplied_bug4", 0, user_supplied_bug4 },
1775   {"user_supplied_bug5", 1, user_supplied_bug5 },
1776   {"user_supplied_bug6", 1, user_supplied_bug6 },
1777   {"user_supplied_bug7", 1, user_supplied_bug7 },
1778   {0, 0, 0}
1779 };
1780
1781 test_st generate_tests[] ={
1782   {"generate_data", 0, generate_data },
1783   {"get_read", 0, get_read },
1784   {"mget_read", 0, mget_read },
1785   {"mget_read_result", 0, mget_read_result },
1786   {"cleanup", 0, cleanup_pairs },
1787   {0, 0, 0}
1788 };
1789
1790
1791 collection_st collection[] ={
1792   {"block", 0, 0, tests},
1793   {"nonblock", pre_nonblock, 0, tests},
1794   {"nodelay", pre_nodelay, 0, tests},
1795   {"md5", pre_md5, 0, tests},
1796   {"crc", pre_crc, 0, tests},
1797   {"hsieh", pre_hsieh, 0, tests},
1798   {"fnv1_64", pre_hash_fnv1_64, 0, tests},
1799   {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
1800   {"fnv1_32", pre_hash_fnv1_32, 0, tests},
1801   {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
1802   {"ketama", pre_hash_ketama, 0, tests},
1803   {"unix_socket", pre_unix_socket, 0, tests},
1804   {"unix_socket_nodelay", pre_nodelay, 0, tests},
1805   {"poll_timeout", poll_timeout, 0, tests},
1806   {"gets", enable_cas, 0, tests},
1807 //  {"udp", pre_udp, 0, tests},
1808   {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
1809   {"string", 0, 0, string_tests},
1810   {"result", 0, 0, result_tests},
1811   {"user", 0, 0, user_tests},
1812   {"generate", 0, 0, generate_tests},
1813   {"generate_hsieh", pre_hsieh, 0, generate_tests},
1814   {"generate_nonblock", pre_nonblock, 0, generate_tests},
1815   {0, 0, 0, 0}
1816 };
1817
1818 collection_st *gets_collections(void)
1819 {
1820   return collection;
1821 }