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      printf("Found key %s\n", *ptr);
 827
 828    free(list);
 829  }
 830
 831  memcached_stat_free(NULL, stat);
 832
 833   return 0;
 834 }
 835
 836 uint8_t add_host_test(memcached_st *memc)
 837 {
 838   unsigned int x;
 839   memcached_server_st *servers;
 840   memcached_return rc;
 841   char servername[]= "0.example.com";
 842
 843   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 844   assert(servers);
 845   assert(1 == memcached_server_list_count(servers));
 846
 847   for (x= 2; x < 20; x++)
 848   {
 849     char buffer[SMALL_STRING_LEN];
 850
 851     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 852     servers= memcached_server_list_append(servers, buffer, 401,
 853                                      &rc);
 854     assert(rc == MEMCACHED_SUCCESS);
 855     assert(x == memcached_server_list_count(servers));
 856   }
 857
 858   rc= memcached_server_push(memc, servers);
 859   assert(rc == MEMCACHED_SUCCESS);
 860   rc= memcached_server_push(memc, servers);
 861   assert(rc == MEMCACHED_SUCCESS);
 862
 863   memcached_server_list_free(servers);
 864
 865   return 0;
 866 }
 867
 868 /* We don't test the behavior itself, we test the switches */
 869 uint8_t behavior_test(memcached_st *memc)
 870 {
 871   unsigned long long value;
 872   unsigned int set= 1;
 873
 874   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 875   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 876   assert(value == 1);
 877
 878   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 879   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 880   assert(value == 1);
 881
 882   set= MEMCACHED_HASH_MD5;
 883   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
 884   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 885   assert(value == MEMCACHED_HASH_MD5);
 886
 887   set= 0;
 888
 889   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 890   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 891   assert(value == 0);
 892
 893   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 894   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 895   assert(value == 0);
 896
 897   set= MEMCACHED_HASH_DEFAULT;
 898   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
 899   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 900   assert(value == MEMCACHED_HASH_DEFAULT);
 901
 902   set= MEMCACHED_HASH_CRC;
 903   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
 904   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 905   assert(value == MEMCACHED_HASH_CRC);
 906
 907   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
 908   assert(value > 0);
 909
 910   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 911   assert(value > 0);
 912
 913   return 0;
 914 }
 915
 916 /* Test case provided by Cal Haldenbrand */
 917 uint8_t user_supplied_bug1(memcached_st *memc)
 918 {
 919   unsigned int setter= 1;
 920   unsigned int x;
 921
 922   unsigned long long total= 0;
 923   int size= 0;
 924   char key[10];
 925   char randomstuff[6 * 1024];
 926   memcached_return rc;
 927
 928   memset(randomstuff, 0, 6 * 1024);
 929
 930   /* We just keep looking at the same values over and over */
 931   srandom(10);
 932
 933   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 934   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 935
 936
 937   /* add key */
 938   for (x= 0 ; total < 20 * 1024576 ; x++ )
 939   {
 940     unsigned int j= 0;
 941
 942     size= (rand() % ( 5 * 1024 ) ) + 400;
 943     memset(randomstuff, 0, 6 * 1024);
 944     assert(size < 6 * 1024); /* Being safe here */
 945
 946     for (j= 0 ; j < size ;j++)
 947       randomstuff[j] = (char) (rand() % 26) + 97;
 948
 949     total += size;
 950     sprintf(key, "%d", x);
 951     rc = memcached_set(memc, key, strlen(key),
 952                        randomstuff, strlen(randomstuff), 10, 0);
 953     /* If we fail, lets try again */
 954     if (rc != MEMCACHED_SUCCESS)
 955       rc = memcached_set(memc, key, strlen(key),
 956                          randomstuff, strlen(randomstuff), 10, 0);
 957     assert(rc == MEMCACHED_SUCCESS);
 958   }
 959
 960   return 0;
 961 }
 962
 963 /* Test case provided by Cal Haldenbrand */
 964 uint8_t user_supplied_bug2(memcached_st *memc)
 965 {
 966   int errors;
 967   unsigned int setter;
 968   unsigned int x;
 969   unsigned long long total;
 970
 971   setter= 1;
 972   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 973   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 974 #ifdef NOT_YET
 975   setter = 20 * 1024576;
 976   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
 977   setter = 20 * 1024576;
 978   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
 979   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
 980   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 981
 982   for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
 983 #endif
 984
 985   for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
 986   {
 987     memcached_return rc= MEMCACHED_SUCCESS;
 988     char buffer[SMALL_STRING_LEN];
 989     uint16_t flags= 0;
 990     size_t val_len= 0;
 991     char *getval;
 992
 993     memset(buffer, 0, SMALL_STRING_LEN);
 994
 995     snprintf(buffer, SMALL_STRING_LEN, "%u", x);
 996     getval= memcached_get(memc, buffer, strlen(buffer),
 997                            &val_len, &flags, &rc);
 998     if (rc != MEMCACHED_SUCCESS)
 999     {
1000       if (rc == MEMCACHED_NOTFOUND)
1001         errors++;
1002       else
1003         assert(0);
1004
1005       continue;
1006     }
1007     total+= val_len;
1008     errors= 0;
1009     free(getval);
1010   }
1011
1012   return 0;
1013 }
1014
1015 /* Do a large mget() over all the keys we think exist */
1016 #define KEY_COUNT 3000 // * 1024576
1017 uint8_t user_supplied_bug3(memcached_st *memc)
1018 {
1019   memcached_return rc;
1020   unsigned int setter;
1021   unsigned int x;
1022   char **keys;
1023   size_t key_lengths[KEY_COUNT];
1024
1025   setter= 1;
1026   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
1027   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
1028 #ifdef NOT_YET
1029   setter = 20 * 1024576;
1030   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
1031   setter = 20 * 1024576;
1032   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
1033   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1034   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1035 #endif
1036
1037   keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
1038   assert(keys);
1039   memset(keys, 0, (sizeof(char *) * KEY_COUNT));
1040   for (x= 0; x < KEY_COUNT; x++)
1041   {
1042     char buffer[30];
1043
1044     snprintf(buffer, 30, "%u", x);
1045     keys[x]= strdup(buffer);
1046     key_lengths[x]= strlen(keys[x]);
1047   }
1048
1049   rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
1050   assert(rc == MEMCACHED_SUCCESS);
1051
1052   /* Turn this into a help function */
1053   {
1054     char return_key[MEMCACHED_MAX_KEY];
1055     size_t return_key_length;
1056     char *return_value;
1057     size_t return_value_length;
1058     uint16_t flags;
1059
1060     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1061                                           &return_value_length, &flags, &rc)))
1062     {
1063       assert(return_value);
1064       assert(rc == MEMCACHED_SUCCESS);
1065       free(return_value);
1066     }
1067   }
1068
1069   for (x= 0; x < KEY_COUNT; x++)
1070     free(keys[x]);
1071   free(keys);
1072
1073   return 0;
1074 }
1075
1076 /* Make sure we behave properly if server list has no values */
1077 uint8_t user_supplied_bug4(memcached_st *memc)
1078 {
1079   memcached_return rc;
1080   char *keys[]= {"fudge", "son", "food"};
1081   size_t key_length[]= {5, 3, 4};
1082   unsigned int x;
1083   uint16_t flags;
1084
1085   /* Here we free everything before running a bunch of mget tests */
1086   {
1087     memcached_server_list_free(memc->hosts);
1088     memc->hosts= NULL;
1089     memc->number_of_hosts= 0;
1090   }
1091
1092   char return_key[MEMCACHED_MAX_KEY];
1093   size_t return_key_length;
1094   char *return_value;
1095   size_t return_value_length;
1096
1097   /* We need to empty the server before continueing test */
1098   rc= memcached_flush(memc, 0);
1099   assert(rc == MEMCACHED_NO_SERVERS);
1100
1101   rc= memcached_mget(memc, keys, key_length, 3);
1102   assert(rc == MEMCACHED_NO_SERVERS);
1103
1104   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1105                       &return_value_length, &flags, &rc)) != NULL)
1106   {
1107     assert(return_value);
1108   }
1109   assert(!return_value);
1110   assert(return_value_length == 0);
1111   assert(rc == MEMCACHED_NO_SERVERS);
1112
1113   for (x= 0; x < 3; x++)
1114   {
1115     rc= memcached_set(memc, keys[x], key_length[x],
1116                       keys[x], key_length[x],
1117                       (time_t)50, (uint16_t)9);
1118     assert(rc == MEMCACHED_NO_SERVERS);
1119   }
1120
1121   rc= memcached_mget(memc, keys, key_length, 3);
1122   assert(rc == MEMCACHED_NO_SERVERS);
1123
1124   x= 0;
1125   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1126                                         &return_value_length, &flags, &rc)))
1127   {
1128     assert(return_value);
1129     assert(rc == MEMCACHED_SUCCESS);
1130     assert(return_key_length == return_value_length);
1131     assert(!memcmp(return_value, return_key, return_value_length));
1132     free(return_value);
1133     x++;
1134   }
1135
1136   return 0;
1137 }
1138
1139 #define VALUE_SIZE_BUG5 1048064
1140 uint8_t user_supplied_bug5(memcached_st *memc)
1141 {
1142   memcached_return rc;
1143   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1144   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1145   char return_key[MEMCACHED_MAX_KEY];
1146   size_t return_key_length;
1147   char *value;
1148   size_t value_length;
1149   uint16_t flags;
1150   unsigned int count;
1151   unsigned int x;
1152   char insert_data[VALUE_SIZE_BUG5];
1153
1154   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1155     insert_data[x]= rand();
1156
1157   memcached_flush(memc, 0);
1158   value= memcached_get(memc, keys[0], key_length[0],
1159                         &value_length, &flags, &rc);
1160   assert(value == NULL);
1161   rc= memcached_mget(memc, keys, key_length, 4);
1162
1163   count= 0;
1164   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1165                                         &value_length, &flags, &rc)))
1166     count++;
1167   assert(count == 0);
1168
1169   for (x= 0; x < 4; x++)
1170   {
1171     rc= memcached_set(memc, keys[x], key_length[x],
1172                       insert_data, VALUE_SIZE_BUG5,
1173                       (time_t)0, (uint16_t)0);
1174     assert(rc == MEMCACHED_SUCCESS);
1175   }
1176
1177   for (x= 0; x < 10; x++)
1178   {
1179     value= memcached_get(memc, keys[0], key_length[0],
1180                          &value_length, &flags, &rc);
1181     assert(value);
1182     free(value);
1183
1184     rc= memcached_mget(memc, keys, key_length, 4);
1185     count= 0;
1186     while ((value= memcached_fetch(memc, return_key, &return_key_length,
1187                                           &value_length, &flags, &rc)))
1188     {
1189       count++;
1190       free(value);
1191     }
1192     assert(count == 4);
1193   }
1194
1195   return 0;
1196 }
1197
1198 uint8_t user_supplied_bug6(memcached_st *memc)
1199 {
1200   memcached_return rc;
1201   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1202   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1203   char return_key[MEMCACHED_MAX_KEY];
1204   size_t return_key_length;
1205   char *value;
1206   size_t value_length;
1207   uint16_t flags;
1208   unsigned int count;
1209   unsigned int x;
1210   char insert_data[VALUE_SIZE_BUG5];
1211
1212   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1213     insert_data[x]= rand();
1214
1215   memcached_flush(memc, 0);
1216   value= memcached_get(memc, keys[0], key_length[0],
1217                         &value_length, &flags, &rc);
1218   assert(value == NULL);
1219   rc= memcached_mget(memc, keys, key_length, 4);
1220
1221   count= 0;
1222   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1223                                         &value_length, &flags, &rc)))
1224     count++;
1225   assert(count == 0);
1226
1227   for (x= 0; x < 4; x++)
1228   {
1229     rc= memcached_set(memc, keys[x], key_length[x],
1230                       insert_data, VALUE_SIZE_BUG5,
1231                       (time_t)0, (uint16_t)0);
1232     assert(rc == MEMCACHED_SUCCESS);
1233   }
1234
1235   for (x= 0; x < 10; x++)
1236   {
1237     value= memcached_get(memc, keys[0], key_length[0],
1238                          &value_length, &flags, &rc);
1239     assert(value);
1240     free(value);
1241
1242     rc= memcached_mget(memc, keys, key_length, 4);
1243     count= 3;
1244     /* We test for purge of partial complete fetches */
1245     for (count= 3; count; count--)
1246     {
1247       value= memcached_fetch(memc, return_key, &return_key_length,
1248                              &value_length, &flags, &rc);
1249       free(value);
1250       assert(rc == MEMCACHED_SUCCESS);
1251     }
1252   }
1253
1254   return 0;
1255 }
1256
1257 /* Test flag store/retrieve */
1258 uint8_t user_supplied_bug7(memcached_st *memc)
1259 {
1260   memcached_return rc;
1261   char *keys= "036790384900";
1262   size_t key_length=  strlen("036790384900");
1263   char return_key[MEMCACHED_MAX_KEY];
1264   size_t return_key_length;
1265   char *value;
1266   size_t value_length;
1267   uint16_t flags;
1268   unsigned int x;
1269   char insert_data[VALUE_SIZE_BUG5];
1270
1271   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1272     insert_data[x]= rand();
1273
1274   memcached_flush(memc, 0);
1275
1276   flags= 245;
1277   rc= memcached_set(memc, keys, key_length,
1278                     insert_data, VALUE_SIZE_BUG5,
1279                     (time_t)0, flags);
1280   assert(rc == MEMCACHED_SUCCESS);
1281
1282   flags= 0;
1283   value= memcached_get(memc, keys, key_length,
1284                         &value_length, &flags, &rc);
1285   assert(flags == 245);
1286   assert(value);
1287   free(value);
1288
1289   rc= memcached_mget(memc, &keys, &key_length, 1);
1290
1291   flags= 0;
1292   value= memcached_fetch(memc, return_key, &return_key_length,
1293                          &value_length, &flags, &rc);
1294   assert(flags == 245);
1295   assert(value);
1296   free(value);
1297
1298
1299   return 0;
1300 }
1301
1302 uint8_t result_static(memcached_st *memc)
1303 {
1304   memcached_result_st result;
1305   memcached_result_st *result_ptr;
1306
1307   result_ptr= memcached_result_create(memc, &result);
1308   assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
1309   assert(result_ptr);
1310   memcached_result_free(&result);
1311
1312   return 0;
1313 }
1314
1315 uint8_t result_alloc(memcached_st *memc)
1316 {
1317   memcached_result_st *result;
1318
1319   result= memcached_result_create(memc, NULL);
1320   assert(result);
1321   memcached_result_free(result);
1322
1323   return 0;
1324 }
1325
1326 uint8_t string_static_null(memcached_st *memc)
1327 {
1328   memcached_string_st string;
1329   memcached_string_st *string_ptr;
1330
1331   string_ptr= memcached_string_create(memc, &string, 0);
1332   assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
1333   assert(string_ptr);
1334   memcached_string_free(&string);
1335
1336   return 0;
1337 }
1338
1339 uint8_t string_alloc_null(memcached_st *memc)
1340 {
1341   memcached_string_st *string;
1342
1343   string= memcached_string_create(memc, NULL, 0);
1344   assert(string);
1345   memcached_string_free(string);
1346
1347   return 0;
1348 }
1349
1350 uint8_t string_alloc_with_size(memcached_st *memc)
1351 {
1352   memcached_string_st *string;
1353
1354   string= memcached_string_create(memc, NULL, 1024);
1355   assert(string);
1356   memcached_string_free(string);
1357
1358   return 0;
1359 }
1360
1361 uint8_t string_alloc_with_size_toobig(memcached_st *memc)
1362 {
1363   memcached_string_st *string;
1364
1365   string= memcached_string_create(memc, NULL, INT64_MAX);
1366   assert(string == NULL);
1367
1368   return 0;
1369 }
1370
1371 uint8_t string_alloc_append(memcached_st *memc)
1372 {
1373   unsigned int x;
1374   char buffer[SMALL_STRING_LEN];
1375   memcached_string_st *string;
1376
1377   /* Ring the bell! */
1378   memset(buffer, 6, SMALL_STRING_LEN);
1379
1380   string= memcached_string_create(memc, NULL, 100);
1381   assert(string);
1382
1383   for (x= 0; x < 1024; x++)
1384   {
1385     memcached_return rc;
1386     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1387     assert(rc == MEMCACHED_SUCCESS);
1388   }
1389   memcached_string_free(string);
1390
1391   return 0;
1392 }
1393
1394 uint8_t string_alloc_append_toobig(memcached_st *memc)
1395 {
1396   memcached_return rc;
1397   unsigned int x;
1398   char buffer[SMALL_STRING_LEN];
1399   memcached_string_st *string;
1400
1401   /* Ring the bell! */
1402   memset(buffer, 6, SMALL_STRING_LEN);
1403
1404   string= memcached_string_create(memc, NULL, 100);
1405   assert(string);
1406
1407   for (x= 0; x < 1024; x++)
1408   {
1409     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1410     assert(rc == MEMCACHED_SUCCESS);
1411   }
1412   rc= memcached_string_append(string, buffer, INT64_MAX);
1413   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
1414   memcached_string_free(string);
1415
1416   return 0;
1417 }
1418
1419 uint8_t cleanup_pairs(memcached_st *memc)
1420 {
1421   pairs_free(global_pairs);
1422
1423   return 0;
1424 }
1425
1426 uint8_t generate_data(memcached_st *memc)
1427 {
1428   unsigned long long x;
1429   global_pairs= pairs_generate(GLOBAL_COUNT);
1430   execute_set(memc, global_pairs, GLOBAL_COUNT);
1431
1432   for (x= 0; x < GLOBAL_COUNT; x++)
1433   {
1434     global_keys[x]= global_pairs[x].key;
1435     global_keys_length[x]=  global_pairs[x].key_length;
1436   }
1437
1438   return 0;
1439 }
1440
1441 uint8_t get_read(memcached_st *memc)
1442 {
1443   unsigned int x;
1444   memcached_return rc;
1445
1446   {
1447     char *return_value;
1448     size_t return_value_length;
1449     uint16_t flags;
1450
1451     for (x= 0; x < GLOBAL_COUNT; x++)
1452     {
1453       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
1454                                   &return_value_length, &flags, &rc);
1455       /*
1456       assert(return_value);
1457       assert(rc == MEMCACHED_SUCCESS);
1458     */
1459       if (rc == MEMCACHED_SUCCESS && return_value)
1460         free(return_value);
1461     }
1462   }
1463
1464   return 0;
1465 }
1466
1467 uint8_t mget_read(memcached_st *memc)
1468 {
1469   memcached_return rc;
1470
1471   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1472   assert(rc == MEMCACHED_SUCCESS);
1473   /* Turn this into a help function */
1474   {
1475     char return_key[MEMCACHED_MAX_KEY];
1476     size_t return_key_length;
1477     char *return_value;
1478     size_t return_value_length;
1479     uint16_t flags;
1480
1481     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1482                                           &return_value_length, &flags, &rc)))
1483     {
1484       assert(return_value);
1485       assert(rc == MEMCACHED_SUCCESS);
1486       free(return_value);
1487     }
1488   }
1489
1490   return 0;
1491 }
1492
1493 uint8_t mget_read_result(memcached_st *memc)
1494 {
1495   memcached_return rc;
1496
1497   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1498   assert(rc == MEMCACHED_SUCCESS);
1499   /* Turn this into a help function */
1500   {
1501     memcached_result_st results_obj;
1502     memcached_result_st *results;
1503
1504     results= memcached_result_create(memc, &results_obj);
1505
1506     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1507     {
1508       assert(results);
1509       assert(rc == MEMCACHED_SUCCESS);
1510     }
1511
1512     memcached_result_free(&results_obj);
1513   }
1514
1515   return 0;
1516 }
1517
1518 uint8_t free_data(memcached_st *memc)
1519 {
1520   pairs_free(global_pairs);
1521
1522   return 0;
1523 }
1524
1525 uint8_t add_host_test1(memcached_st *memc)
1526 {
1527   unsigned int x;
1528   memcached_return rc;
1529   char servername[]= "0.example.com";
1530   memcached_server_st *servers;
1531
1532   servers= memcached_server_list_append(NULL, servername, 400, &rc);
1533   assert(servers);
1534   assert(1 == memcached_server_list_count(servers));
1535
1536   for (x= 2; x < 20; x++)
1537   {
1538     char buffer[SMALL_STRING_LEN];
1539
1540     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1541     servers= memcached_server_list_append(servers, buffer, 401,
1542                                      &rc);
1543     assert(rc == MEMCACHED_SUCCESS);
1544     assert(x == memcached_server_list_count(servers));
1545   }
1546
1547   rc= memcached_server_push(memc, servers);
1548   assert(rc == MEMCACHED_SUCCESS);
1549   rc= memcached_server_push(memc, servers);
1550   assert(rc == MEMCACHED_SUCCESS);
1551
1552   memcached_server_list_free(servers);
1553
1554   return 0;
1555 }
1556
1557 memcached_return pre_nonblock(memcached_st *memc)
1558 {
1559   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1560
1561   return MEMCACHED_SUCCESS;
1562 }
1563
1564 memcached_return pre_md5(memcached_st *memc)
1565 {
1566   memcached_hash value= MEMCACHED_HASH_MD5;
1567   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1568
1569   return MEMCACHED_SUCCESS;
1570 }
1571
1572 memcached_return pre_crc(memcached_st *memc)
1573 {
1574   memcached_hash value= MEMCACHED_HASH_CRC;
1575   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1576
1577   return MEMCACHED_SUCCESS;
1578 }
1579
1580 memcached_return pre_hash_fnv1_64(memcached_st *memc)
1581 {
1582   memcached_hash value= MEMCACHED_HASH_FNV1_64;
1583   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1584
1585   return MEMCACHED_SUCCESS;
1586 }
1587
1588 memcached_return pre_hash_fnv1a_64(memcached_st *memc)
1589 {
1590   memcached_hash value= MEMCACHED_HASH_FNV1A_64;
1591   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1592
1593   return MEMCACHED_SUCCESS;
1594 }
1595
1596 memcached_return pre_hash_fnv1_32(memcached_st *memc)
1597 {
1598   memcached_hash value= MEMCACHED_HASH_FNV1_32;
1599   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1600
1601   return MEMCACHED_SUCCESS;
1602 }
1603
1604 memcached_return pre_hash_fnv1a_32(memcached_st *memc)
1605 {
1606   memcached_hash value= MEMCACHED_HASH_FNV1A_32;
1607   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1608
1609   return MEMCACHED_SUCCESS;
1610 }
1611
1612 memcached_return pre_hash_ketama(memcached_st *memc)
1613 {
1614   memcached_hash value= MEMCACHED_HASH_KETAMA;
1615   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1616
1617   return MEMCACHED_SUCCESS;
1618 }
1619
1620 memcached_return enable_cas(memcached_st *memc)
1621 {
1622   unsigned int set= 1;
1623
1624   memcached_version(memc);
1625
1626   if (memc->hosts[0].major_version >= 1 &&
1627       memc->hosts[0].minor_version >= 2 &&
1628       memc->hosts[0].micro_version >= 4)
1629   {
1630     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
1631
1632     return MEMCACHED_SUCCESS;
1633   }
1634
1635   return MEMCACHED_FAILURE;
1636 }
1637
1638 memcached_return check_for_1_2_3(memcached_st *memc)
1639 {
1640   memcached_version(memc);
1641
1642   if (memc->hosts[0].major_version >= 1 &&
1643       memc->hosts[0].minor_version >= 2 &&
1644       memc->hosts[0].micro_version >= 4)
1645     return MEMCACHED_SUCCESS;
1646
1647   return MEMCACHED_FAILURE;
1648 }
1649
1650 memcached_return pre_unix_socket(memcached_st *memc)
1651 {
1652   memcached_return rc;
1653   struct stat buf;
1654
1655   memcached_server_list_free(memc->hosts);
1656   memc->hosts= NULL;
1657   memc->number_of_hosts= 0;
1658
1659   if (stat("/tmp/memcached.socket", &buf))
1660     return MEMCACHED_FAILURE;
1661
1662   rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");
1663
1664   return rc;
1665 }
1666
1667 memcached_return pre_udp(memcached_st *memc)
1668 {
1669   memcached_return rc;
1670
1671   memcached_server_list_free(memc->hosts);
1672   memc->hosts= NULL;
1673   memc->number_of_hosts= 0;
1674
1675   if (0)
1676     return MEMCACHED_FAILURE;
1677
1678   rc= memcached_server_add_udp(memc, "localhost", MEMCACHED_DEFAULT_PORT);
1679
1680   return rc;
1681 }
1682
1683 memcached_return pre_nodelay(memcached_st *memc)
1684 {
1685   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1686   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
1687
1688   return MEMCACHED_SUCCESS;
1689 }
1690
1691 memcached_return poll_timeout(memcached_st *memc)
1692 {
1693   int32_t timeout;
1694
1695   timeout= 100;
1696
1697   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
1698
1699   timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
1700
1701   assert(timeout == 100);
1702
1703   return MEMCACHED_SUCCESS;
1704 }
1705
1706
1707 /* Clean the server before beginning testing */
1708 test_st tests[] ={
1709   {"flush", 0, flush_test },
1710   {"init", 0, init_test },
1711   {"allocation", 0, allocation_test },
1712   {"clone_test", 0, clone_test },
1713   {"error", 0, error_test },
1714   {"set", 0, set_test },
1715   {"set2", 0, set_test2 },
1716   {"set3", 0, set_test3 },
1717   {"add", 0, add_test },
1718   {"replace", 0, replace_test },
1719   {"delete", 1, delete_test },
1720   {"get", 1, get_test },
1721   {"get2", 0, get_test2 },
1722   {"get3", 0, get_test3 },
1723   {"get4", 0, get_test4 },
1724   {"stats_servername", 0, stats_servername_test },
1725   {"increment", 0, increment_test },
1726   {"decrement", 0, decrement_test },
1727   {"quit", 0, quit_test },
1728   {"mget", 1, mget_test },
1729   {"mget_result", 1, mget_result_test },
1730   {"mget_result_alloc", 1, mget_result_alloc_test },
1731   {"get_stats", 0, get_stats },
1732   {"add_host_test", 0, add_host_test },
1733   {"get_stats_keys", 0, get_stats_keys },
1734   {"behavior_test", 0, get_stats_keys },
1735   {0, 0, 0}
1736 };
1737
1738 test_st string_tests[] ={
1739   {"string static with null", 0, string_static_null },
1740   {"string alloc with null", 0, string_alloc_null },
1741   {"string alloc with 1K", 0, string_alloc_with_size },
1742   {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
1743   {"string append", 0, string_alloc_append },
1744   {"string append failure (too big)", 0, string_alloc_append_toobig },
1745   {0, 0, 0}
1746 };
1747
1748 test_st result_tests[] ={
1749   {"result static", 0, result_static},
1750   {"result alloc", 0, result_alloc},
1751   {0, 0, 0}
1752 };
1753
1754 test_st version_1_2_3[] ={
1755   {"append", 0, append_test },
1756   {"prepend", 0, prepend_test },
1757   {"cas", 0, cas_test },
1758   {"cas2", 0, cas2_test },
1759   {"append_binary", 0, append_binary_test },
1760   {0, 0, 0}
1761 };
1762
1763 test_st user_tests[] ={
1764   {"user_supplied_bug1", 0, user_supplied_bug1 },
1765   {"user_supplied_bug2", 0, user_supplied_bug2 },
1766   {"user_supplied_bug3", 0, user_supplied_bug3 },
1767   {"user_supplied_bug4", 0, user_supplied_bug4 },
1768   {"user_supplied_bug5", 1, user_supplied_bug5 },
1769   {"user_supplied_bug6", 1, user_supplied_bug6 },
1770   {"user_supplied_bug7", 1, user_supplied_bug7 },
1771   {0, 0, 0}
1772 };
1773
1774 test_st generate_tests[] ={
1775   {"generate_data", 0, generate_data },
1776   {"get_read", 0, get_read },
1777   {"mget_read", 0, mget_read },
1778   {"mget_read_result", 0, mget_read_result },
1779   {"cleanup", 0, cleanup_pairs },
1780   {0, 0, 0}
1781 };
1782
1783
1784 collection_st collection[] ={
1785   {"block", 0, 0, tests},
1786   {"nonblock", pre_nonblock, 0, tests},
1787   {"nodelay", pre_nodelay, 0, tests},
1788   {"md5", pre_md5, 0, tests},
1789   {"crc", pre_crc, 0, tests},
1790   {"fnv1_64", pre_hash_fnv1_64, 0, tests},
1791   {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
1792   {"fnv1_32", pre_hash_fnv1_32, 0, tests},
1793   {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
1794   {"ketama", pre_hash_ketama, 0, tests},
1795   {"unix_socket", pre_unix_socket, 0, tests},
1796   {"unix_socket_nodelay", pre_nodelay, 0, tests},
1797   {"poll_timeout", poll_timeout, 0, tests},
1798   {"gets", enable_cas, 0, tests},
1799 //  {"udp", pre_udp, 0, tests},
1800   {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
1801   {"string", 0, 0, string_tests},
1802   {"result", 0, 0, result_tests},
1803   {"user", 0, 0, user_tests},
1804   {"generate", 0, 0, generate_tests},
1805   {"generate_nonblock", pre_nonblock, 0, generate_tests},
1806   {0, 0, 0, 0}
1807 };
1808
1809 collection_st *gets_collections(void)
1810 {
1811   return collection;
1812 }