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   WATCHPOINT_ERROR(rc);
 116   assert(rc == MEMCACHED_SUCCESS);
 117
 118   return 0;
 119 }
 120
 121 uint8_t append_test(memcached_st *memc)
 122 {
 123   memcached_return rc;
 124   char *key= "fig";
 125   char *value= "we";
 126   size_t value_length;
 127   uint16_t flags;
 128
 129   rc= memcached_flush(memc, 0);
 130   assert(rc == MEMCACHED_SUCCESS);
 131
 132   rc= memcached_set(memc, key, strlen(key),
 133                     value, strlen(value),
 134                     (time_t)0, (uint16_t)0);
 135   assert(rc == MEMCACHED_SUCCESS);
 136
 137   rc= memcached_append(memc, key, strlen(key),
 138                        " the", strlen(" the"),
 139                        (time_t)0, (uint16_t)0);
 140   assert(rc == MEMCACHED_SUCCESS);
 141
 142   rc= memcached_append(memc, key, strlen(key),
 143                        " people", strlen(" people"),
 144                        (time_t)0, (uint16_t)0);
 145   assert(rc == MEMCACHED_SUCCESS);
 146
 147   value= memcached_get(memc, key, strlen(key),
 148                        &value_length, &flags, &rc);
 149   assert(!memcmp(value, "we the people", strlen("we the people")));
 150   assert(strlen("we the people") == value_length);
 151   assert(rc == MEMCACHED_SUCCESS);
 152   free(value);
 153
 154   return 0;
 155 }
 156
 157 uint8_t append_binary_test(memcached_st *memc)
 158 {
 159   memcached_return rc;
 160   char *key= "numbers";
 161   unsigned int *store_ptr;
 162   unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
 163   char *value;
 164   size_t value_length;
 165   uint16_t flags;
 166   unsigned int x;
 167
 168   rc= memcached_flush(memc, 0);
 169   assert(rc == MEMCACHED_SUCCESS);
 170
 171   rc= memcached_set(memc,
 172                     key, strlen(key),
 173                     NULL, 0,
 174                     (time_t)0, (uint16_t)0);
 175   assert(rc == MEMCACHED_SUCCESS);
 176
 177   for (x= 0; store_list[x] ; x++)
 178   {
 179     rc= memcached_append(memc,
 180                          key, strlen(key),
 181                          (char *)&store_list[x], sizeof(unsigned int),
 182                          (time_t)0, (uint16_t)0);
 183     assert(rc == MEMCACHED_SUCCESS);
 184   }
 185
 186   value= memcached_get(memc, key, strlen(key),
 187                        &value_length, &flags, &rc);
 188   assert((value_length == (sizeof(unsigned int) * x)));
 189   assert(rc == MEMCACHED_SUCCESS);
 190
 191   store_ptr= (unsigned int *)value;
 192   x= 0;
 193   while ((size_t)store_ptr < (size_t)(value + value_length))
 194   {
 195     assert(*store_ptr == store_list[x++]);
 196     store_ptr++;
 197   }
 198   free(value);
 199
 200   return 0;
 201 }
 202
 203 uint8_t cas2_test(memcached_st *memc)
 204 {
 205   memcached_return rc;
 206   char *keys[]= {"fudge", "son", "food"};
 207   size_t key_length[]= {5, 3, 4};
 208   char *value= "we the people";
 209   size_t value_length= strlen("we the people");
 210   unsigned int x;
 211   memcached_result_st results_obj;
 212   memcached_result_st *results;
 213   unsigned int set= 1;
 214
 215   rc= memcached_flush(memc, 0);
 216   assert(rc == MEMCACHED_SUCCESS);
 217
 218   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
 219
 220   for (x= 0; x < 3; x++)
 221   {
 222     rc= memcached_set(memc, keys[x], key_length[x],
 223                       keys[x], key_length[x],
 224                       (time_t)50, (uint16_t)9);
 225     assert(rc == MEMCACHED_SUCCESS);
 226   }
 227
 228   rc= memcached_mget(memc, keys, key_length, 3);
 229
 230   results= memcached_result_create(memc, &results_obj);
 231
 232   results= memcached_fetch_result(memc, &results_obj, &rc);
 233   assert(results);
 234   assert(results->cas);
 235   assert(rc == MEMCACHED_SUCCESS);
 236   WATCHPOINT_ASSERT(memcached_result_cas(results));
 237
 238   assert(!memcmp(value, "we the people", strlen("we the people")));
 239   assert(strlen("we the people") == value_length);
 240   assert(rc == MEMCACHED_SUCCESS);
 241
 242   memcached_result_free(&results_obj);
 243
 244   return 0;
 245 }
 246
 247 uint8_t cas_test(memcached_st *memc)
 248 {
 249   memcached_return rc;
 250   char *key= "fun";
 251   size_t key_length= strlen("fun");
 252   char *value= "we the people";
 253   size_t value_length= strlen("we the people");
 254   memcached_result_st results_obj;
 255   memcached_result_st *results;
 256   unsigned int set= 1;
 257
 258   rc= memcached_flush(memc, 0);
 259   assert(rc == MEMCACHED_SUCCESS);
 260
 261   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
 262
 263   rc= memcached_set(memc, key, strlen(key),
 264                     value, strlen(value),
 265                     (time_t)0, (uint16_t)0);
 266   assert(rc == MEMCACHED_SUCCESS);
 267
 268   rc= memcached_mget(memc, &key, &key_length, 1);
 269
 270   results= memcached_result_create(memc, &results_obj);
 271
 272   results= memcached_fetch_result(memc, &results_obj, &rc);
 273   assert(results);
 274   assert(rc == MEMCACHED_SUCCESS);
 275   WATCHPOINT_ASSERT(memcached_result_cas(results));
 276
 277   assert(!memcmp(value, "we the people", strlen("we the people")));
 278   assert(strlen("we the people") == value_length);
 279   assert(rc == MEMCACHED_SUCCESS);
 280
 281   memcached_result_free(&results_obj);
 282
 283   return 0;
 284 }
 285
 286 uint8_t prepend_test(memcached_st *memc)
 287 {
 288   memcached_return rc;
 289   char *key= "fig";
 290   char *value= "people";
 291   size_t value_length;
 292   uint16_t flags;
 293
 294   rc= memcached_flush(memc, 0);
 295   assert(rc == MEMCACHED_SUCCESS);
 296
 297   rc= memcached_set(memc, key, strlen(key),
 298                     value, strlen(value),
 299                     (time_t)0, (uint16_t)0);
 300   assert(rc == MEMCACHED_SUCCESS);
 301
 302   rc= memcached_prepend(memc, key, strlen(key),
 303                        "the ", strlen("the "),
 304                        (time_t)0, (uint16_t)0);
 305   assert(rc == MEMCACHED_SUCCESS);
 306
 307   rc= memcached_prepend(memc, key, strlen(key),
 308                        "we ", strlen("we "),
 309                        (time_t)0, (uint16_t)0);
 310   assert(rc == MEMCACHED_SUCCESS);
 311
 312   value= memcached_get(memc, key, strlen(key),
 313                        &value_length, &flags, &rc);
 314   assert(!memcmp(value, "we the people", strlen("we the people")));
 315   assert(strlen("we the people") == value_length);
 316   assert(rc == MEMCACHED_SUCCESS);
 317   free(value);
 318
 319   return 0;
 320 }
 321
 322 uint8_t add_test(memcached_st *memc)
 323 {
 324   memcached_return rc;
 325   char *key= "foo";
 326   char *value= "when we sanitize";
 327
 328   rc= memcached_add(memc, key, strlen(key),
 329                     value, strlen(value),
 330                     (time_t)0, (uint16_t)0);
 331   assert(rc == MEMCACHED_NOTSTORED);
 332
 333   return 0;
 334 }
 335
 336 uint8_t replace_test(memcached_st *memc)
 337 {
 338   memcached_return rc;
 339   char *key= "foo";
 340   char *value= "when we sanitize";
 341
 342   rc= memcached_replace(memc, key, strlen(key),
 343                     value, strlen(value),
 344                     (time_t)0, (uint16_t)0);
 345   assert(rc == MEMCACHED_SUCCESS);
 346
 347   return 0;
 348 }
 349
 350 uint8_t delete_test(memcached_st *memc)
 351 {
 352   memcached_return rc;
 353   char *key= "foo";
 354   char *value= "when we sanitize";
 355
 356   rc= memcached_set(memc, key, strlen(key),
 357                     value, strlen(value),
 358                     (time_t)0, (uint16_t)0);
 359   assert(rc == MEMCACHED_SUCCESS);
 360
 361   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 362   assert(rc == MEMCACHED_SUCCESS);
 363
 364   return 0;
 365 }
 366
 367 uint8_t flush_test(memcached_st *memc)
 368 {
 369   memcached_return rc;
 370
 371   rc= memcached_flush(memc, 0);
 372   assert(rc == MEMCACHED_SUCCESS);
 373
 374   return 0;
 375 }
 376
 377 uint8_t get_test(memcached_st *memc)
 378 {
 379   memcached_return rc;
 380   char *key= "foo";
 381   char *string;
 382   size_t string_length;
 383   uint16_t flags;
 384
 385   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 386   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND);
 387
 388   string= memcached_get(memc, key, strlen(key),
 389                         &string_length, &flags, &rc);
 390
 391   assert(rc == MEMCACHED_NOTFOUND);
 392   assert(string_length ==  0);
 393   assert(!string);
 394
 395   return 0;
 396 }
 397
 398 uint8_t get_test2(memcached_st *memc)
 399 {
 400   memcached_return rc;
 401   char *key= "foo";
 402   char *value= "when we sanitize";
 403   char *string;
 404   size_t string_length;
 405   uint16_t flags;
 406
 407   rc= memcached_set(memc, key, strlen(key),
 408                     value, strlen(value),
 409                     (time_t)0, (uint16_t)0);
 410   assert(rc == MEMCACHED_SUCCESS);
 411
 412   string= memcached_get(memc, key, strlen(key),
 413                         &string_length, &flags, &rc);
 414
 415   assert(string);
 416   assert(rc == MEMCACHED_SUCCESS);
 417   assert(string_length == strlen(value));
 418   assert(!memcmp(string, value, string_length));
 419
 420   free(string);
 421
 422   return 0;
 423 }
 424
 425 uint8_t set_test2(memcached_st *memc)
 426 {
 427   memcached_return rc;
 428   char *key= "foo";
 429   char *value= "train in the brain";
 430   size_t value_length= strlen(value);
 431   unsigned int x;
 432
 433   for (x= 0; x < 10; x++)
 434   {
 435     rc= memcached_set(memc, key, strlen(key),
 436                       value, value_length,
 437                       (time_t)0, (uint16_t)0);
 438     assert(rc == MEMCACHED_SUCCESS);
 439   }
 440
 441   return 0;
 442 }
 443
 444 uint8_t set_test3(memcached_st *memc)
 445 {
 446   memcached_return rc;
 447   char *key= "foo";
 448   char *value;
 449   size_t value_length= 8191;
 450   unsigned int x;
 451
 452   value = (char*)malloc(value_length);
 453   assert(value);
 454
 455   for (x= 0; x < value_length; x++)
 456     value[x] = (char) (x % 127);
 457
 458   for (x= 0; x < 1; x++)
 459   {
 460     rc= memcached_set(memc, key, strlen(key),
 461                       value, value_length,
 462                       (time_t)0, (uint16_t)0);
 463     assert(rc == MEMCACHED_SUCCESS);
 464   }
 465
 466   free(value);
 467
 468   return 0;
 469 }
 470
 471 uint8_t get_test3(memcached_st *memc)
 472 {
 473   memcached_return rc;
 474   char *key= "foo";
 475   char *value;
 476   size_t value_length= 8191;
 477   char *string;
 478   size_t string_length;
 479   uint16_t flags;
 480   int x;
 481
 482   value = (char*)malloc(value_length);
 483   assert(value);
 484
 485   for (x= 0; x < value_length; x++)
 486     value[x] = (char) (x % 127);
 487
 488   rc= memcached_set(memc, key, strlen(key),
 489                     value, value_length,
 490                     (time_t)0, (uint16_t)0);
 491   assert(rc == MEMCACHED_SUCCESS);
 492
 493   string= memcached_get(memc, key, strlen(key),
 494                         &string_length, &flags, &rc);
 495
 496   assert(rc == MEMCACHED_SUCCESS);
 497   assert(string);
 498   assert(string_length == value_length);
 499   assert(!memcmp(string, value, string_length));
 500
 501   free(string);
 502   free(value);
 503
 504   return 0;
 505 }
 506
 507 uint8_t get_test4(memcached_st *memc)
 508 {
 509   memcached_return rc;
 510   char *key= "foo";
 511   char *value;
 512   size_t value_length= 8191;
 513   char *string;
 514   size_t string_length;
 515   uint16_t flags;
 516   int x;
 517
 518   value = (char*)malloc(value_length);
 519   assert(value);
 520
 521   for (x= 0; x < value_length; x++)
 522     value[x] = (char) (x % 127);
 523
 524   rc= memcached_set(memc, key, strlen(key),
 525                     value, value_length,
 526                     (time_t)0, (uint16_t)0);
 527   assert(rc == MEMCACHED_SUCCESS);
 528
 529   for (x= 0; x < 10; x++)
 530   {
 531     string= memcached_get(memc, key, strlen(key),
 532                           &string_length, &flags, &rc);
 533
 534     assert(rc == MEMCACHED_SUCCESS);
 535     assert(string);
 536     assert(string_length == value_length);
 537     assert(!memcmp(string, value, string_length));
 538     free(string);
 539   }
 540
 541   free(value);
 542
 543   return 0;
 544 }
 545
 546 /* Do not copy the style of this code, I just access hosts to testthis function */
 547 uint8_t stats_servername_test(memcached_st *memc)
 548 {
 549   memcached_return rc;
 550   memcached_stat_st stat;
 551   rc= memcached_stat_servername(&stat, NULL,
 552                                  memc->hosts[0].hostname,
 553                                  memc->hosts[0].port);
 554
 555   return 0;
 556 }
 557
 558 uint8_t increment_test(memcached_st *memc)
 559 {
 560   uint64_t new_number;
 561   memcached_return rc;
 562   char *key= "number";
 563   char *value= "0";
 564
 565   rc= memcached_set(memc, key, strlen(key),
 566                     value, strlen(value),
 567                     (time_t)0, (uint16_t)0);
 568   assert(rc == MEMCACHED_SUCCESS);
 569
 570   rc= memcached_increment(memc, key, strlen(key),
 571                           1, &new_number);
 572   assert(rc == MEMCACHED_SUCCESS);
 573   assert(new_number == 1);
 574
 575   rc= memcached_increment(memc, key, strlen(key),
 576                           1, &new_number);
 577   assert(rc == MEMCACHED_SUCCESS);
 578   assert(new_number == 2);
 579
 580   return 0;
 581 }
 582
 583 uint8_t decrement_test(memcached_st *memc)
 584 {
 585   uint64_t new_number;
 586   memcached_return rc;
 587   char *key= "number";
 588   char *value= "3";
 589
 590   rc= memcached_set(memc, key, strlen(key),
 591                     value, strlen(value),
 592                     (time_t)0, (uint16_t)0);
 593   assert(rc == MEMCACHED_SUCCESS);
 594
 595   rc= memcached_decrement(memc, key, strlen(key),
 596                           1, &new_number);
 597   assert(rc == MEMCACHED_SUCCESS);
 598   assert(new_number == 2);
 599
 600   rc= memcached_decrement(memc, key, strlen(key),
 601                           1, &new_number);
 602   assert(rc == MEMCACHED_SUCCESS);
 603   assert(new_number == 1);
 604
 605   return 0;
 606 }
 607
 608 uint8_t quit_test(memcached_st *memc)
 609 {
 610   memcached_return rc;
 611   char *key= "fudge";
 612   char *value= "sanford and sun";
 613
 614   rc= memcached_set(memc, key, strlen(key),
 615                     value, strlen(value),
 616                     (time_t)10, (uint16_t)3);
 617   assert(rc == MEMCACHED_SUCCESS);
 618   memcached_quit(memc);
 619
 620   rc= memcached_set(memc, key, strlen(key),
 621                     value, strlen(value),
 622                     (time_t)50, (uint16_t)9);
 623   assert(rc == MEMCACHED_SUCCESS);
 624
 625   return 0;
 626 }
 627
 628 uint8_t mget_result_test(memcached_st *memc)
 629 {
 630   memcached_return rc;
 631   char *keys[]= {"fudge", "son", "food"};
 632   size_t key_length[]= {5, 3, 4};
 633   unsigned int x;
 634
 635   memcached_result_st results_obj;
 636   memcached_result_st *results;
 637
 638   results= memcached_result_create(memc, &results_obj);
 639   assert(results);
 640   assert(&results_obj == results);
 641
 642   /* We need to empty the server before continueing test */
 643   rc= memcached_flush(memc, 0);
 644   assert(rc == MEMCACHED_SUCCESS);
 645
 646   rc= memcached_mget(memc, keys, key_length, 3);
 647   assert(rc == MEMCACHED_SUCCESS);
 648
 649   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 650   {
 651     assert(results);
 652   }
 653
 654   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 655   assert(!results);
 656   assert(rc == MEMCACHED_NOTFOUND);
 657
 658   for (x= 0; x < 3; x++)
 659   {
 660     rc= memcached_set(memc, keys[x], key_length[x],
 661                       keys[x], key_length[x],
 662                       (time_t)50, (uint16_t)9);
 663     assert(rc == MEMCACHED_SUCCESS);
 664   }
 665
 666   rc= memcached_mget(memc, keys, key_length, 3);
 667   assert(rc == MEMCACHED_SUCCESS);
 668
 669   while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
 670   {
 671     assert(results);
 672     assert(&results_obj == results);
 673     assert(rc == MEMCACHED_SUCCESS);
 674     assert(memcached_result_key_length(results) == memcached_result_length(results));
 675     assert(!memcmp(memcached_result_key_value(results),
 676                    memcached_result_value(results),
 677                    memcached_result_length(results)));
 678   }
 679
 680   memcached_result_free(&results_obj);
 681
 682   return 0;
 683 }
 684
 685 uint8_t mget_result_alloc_test(memcached_st *memc)
 686 {
 687   memcached_return rc;
 688   char *keys[]= {"fudge", "son", "food"};
 689   size_t key_length[]= {5, 3, 4};
 690   unsigned int x;
 691
 692   memcached_result_st *results;
 693
 694   /* We need to empty the server before continueing test */
 695   rc= memcached_flush(memc, 0);
 696   assert(rc == MEMCACHED_SUCCESS);
 697
 698   rc= memcached_mget(memc, keys, key_length, 3);
 699   assert(rc == MEMCACHED_SUCCESS);
 700
 701   while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
 702   {
 703     assert(results);
 704   }
 705   assert(!results);
 706   assert(rc == MEMCACHED_NOTFOUND);
 707
 708   for (x= 0; x < 3; x++)
 709   {
 710     rc= memcached_set(memc, keys[x], key_length[x],
 711                       keys[x], key_length[x],
 712                       (time_t)50, (uint16_t)9);
 713     assert(rc == MEMCACHED_SUCCESS);
 714   }
 715
 716   rc= memcached_mget(memc, keys, key_length, 3);
 717   assert(rc == MEMCACHED_SUCCESS);
 718
 719   x= 0;
 720   while ((results= memcached_fetch_result(memc, NULL, &rc)))
 721   {
 722     assert(results);
 723     assert(rc == MEMCACHED_SUCCESS);
 724     assert(memcached_result_key_length(results) == memcached_result_length(results));
 725     assert(!memcmp(memcached_result_key_value(results),
 726                    memcached_result_value(results),
 727                    memcached_result_length(results)));
 728     memcached_result_free(results);
 729     x++;
 730   }
 731
 732   return 0;
 733 }
 734
 735 uint8_t mget_test(memcached_st *memc)
 736 {
 737   memcached_return rc;
 738   char *keys[]= {"fudge", "son", "food"};
 739   size_t key_length[]= {5, 3, 4};
 740   unsigned int x;
 741   uint16_t flags;
 742
 743   char return_key[MEMCACHED_MAX_KEY];
 744   size_t return_key_length;
 745   char *return_value;
 746   size_t return_value_length;
 747
 748   /* We need to empty the server before continueing test */
 749   rc= memcached_flush(memc, 0);
 750   assert(rc == MEMCACHED_SUCCESS);
 751
 752   rc= memcached_mget(memc, keys, key_length, 3);
 753   assert(rc == MEMCACHED_SUCCESS);
 754
 755   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 756                       &return_value_length, &flags, &rc)) != NULL)
 757   {
 758     assert(return_value);
 759   }
 760   assert(!return_value);
 761   assert(return_value_length == 0);
 762   assert(rc == MEMCACHED_NOTFOUND);
 763
 764   for (x= 0; x < 3; x++)
 765   {
 766     rc= memcached_set(memc, keys[x], key_length[x],
 767                       keys[x], key_length[x],
 768                       (time_t)50, (uint16_t)9);
 769     assert(rc == MEMCACHED_SUCCESS);
 770   }
 771
 772   rc= memcached_mget(memc, keys, key_length, 3);
 773   assert(rc == MEMCACHED_SUCCESS);
 774
 775   x= 0;
 776   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 777                                         &return_value_length, &flags, &rc)))
 778   {
 779     assert(return_value);
 780     assert(rc == MEMCACHED_SUCCESS);
 781     assert(return_key_length == return_value_length);
 782     assert(!memcmp(return_value, return_key, return_value_length));
 783     free(return_value);
 784     x++;
 785   }
 786
 787   return 0;
 788 }
 789
 790 uint8_t get_stats_keys(memcached_st *memc)
 791 {
 792  char **list;
 793  char **ptr;
 794  memcached_stat_st stat;
 795  memcached_return rc;
 796
 797  list= memcached_stat_get_keys(memc, &stat, &rc);
 798  assert(rc == MEMCACHED_SUCCESS);
 799  for (ptr= list; *ptr; ptr++)
 800    printf("Found key %s\n", *ptr);
 801  fflush(stdout);
 802
 803  free(list);
 804
 805  return 0;
 806 }
 807
 808 uint8_t get_stats(memcached_st *memc)
 809 {
 810  unsigned int x;
 811  char **list;
 812  char **ptr;
 813  memcached_return rc;
 814  memcached_stat_st *stat;
 815
 816  stat= memcached_stat(memc, NULL, &rc);
 817  assert(rc == MEMCACHED_SUCCESS);
 818
 819  assert(rc == MEMCACHED_SUCCESS);
 820  assert(stat);
 821
 822  for (x= 0; x < memcached_server_count(memc); x++)
 823  {
 824    list= memcached_stat_get_keys(memc, stat+x, &rc);
 825    assert(rc == MEMCACHED_SUCCESS);
 826    for (ptr= list; *ptr; 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 uint8_t user_supplied_bug8(memcached_st *memc)
1258 {
1259   memcached_return rc;
1260   memcached_st *mine;
1261   memcached_st *clone;
1262
1263   memcached_server_st *servers;
1264   char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
1265
1266   servers= memcached_servers_parse(server_list);
1267   assert(servers);
1268
1269   mine= memcached_create(NULL);
1270   rc= memcached_server_push(mine, servers);
1271   assert(rc == MEMCACHED_SUCCESS);
1272   memcached_server_list_free(servers);
1273
1274   assert(mine);
1275   clone= memcached_clone(NULL, mine);
1276
1277   memcached_quit(mine);
1278   memcached_quit(clone);
1279
1280
1281   memcached_free(mine);
1282   memcached_free(clone);
1283
1284   return 0;
1285 }
1286
1287 /* Test flag store/retrieve */
1288 uint8_t user_supplied_bug7(memcached_st *memc)
1289 {
1290   memcached_return rc;
1291   char *keys= "036790384900";
1292   size_t key_length=  strlen("036790384900");
1293   char return_key[MEMCACHED_MAX_KEY];
1294   size_t return_key_length;
1295   char *value;
1296   size_t value_length;
1297   uint16_t flags;
1298   unsigned int x;
1299   char insert_data[VALUE_SIZE_BUG5];
1300
1301   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1302     insert_data[x]= rand();
1303
1304   memcached_flush(memc, 0);
1305
1306   flags= 245;
1307   rc= memcached_set(memc, keys, key_length,
1308                     insert_data, VALUE_SIZE_BUG5,
1309                     (time_t)0, flags);
1310   assert(rc == MEMCACHED_SUCCESS);
1311
1312   flags= 0;
1313   value= memcached_get(memc, keys, key_length,
1314                         &value_length, &flags, &rc);
1315   assert(flags == 245);
1316   assert(value);
1317   free(value);
1318
1319   rc= memcached_mget(memc, &keys, &key_length, 1);
1320
1321   flags= 0;
1322   value= memcached_fetch(memc, return_key, &return_key_length,
1323                          &value_length, &flags, &rc);
1324   assert(flags == 245);
1325   assert(value);
1326   free(value);
1327
1328
1329   return 0;
1330 }
1331
1332 uint8_t result_static(memcached_st *memc)
1333 {
1334   memcached_result_st result;
1335   memcached_result_st *result_ptr;
1336
1337   result_ptr= memcached_result_create(memc, &result);
1338   assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
1339   assert(result_ptr);
1340   memcached_result_free(&result);
1341
1342   return 0;
1343 }
1344
1345 uint8_t result_alloc(memcached_st *memc)
1346 {
1347   memcached_result_st *result;
1348
1349   result= memcached_result_create(memc, NULL);
1350   assert(result);
1351   memcached_result_free(result);
1352
1353   return 0;
1354 }
1355
1356 uint8_t string_static_null(memcached_st *memc)
1357 {
1358   memcached_string_st string;
1359   memcached_string_st *string_ptr;
1360
1361   string_ptr= memcached_string_create(memc, &string, 0);
1362   assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
1363   assert(string_ptr);
1364   memcached_string_free(&string);
1365
1366   return 0;
1367 }
1368
1369 uint8_t string_alloc_null(memcached_st *memc)
1370 {
1371   memcached_string_st *string;
1372
1373   string= memcached_string_create(memc, NULL, 0);
1374   assert(string);
1375   memcached_string_free(string);
1376
1377   return 0;
1378 }
1379
1380 uint8_t string_alloc_with_size(memcached_st *memc)
1381 {
1382   memcached_string_st *string;
1383
1384   string= memcached_string_create(memc, NULL, 1024);
1385   assert(string);
1386   memcached_string_free(string);
1387
1388   return 0;
1389 }
1390
1391 uint8_t string_alloc_with_size_toobig(memcached_st *memc)
1392 {
1393   memcached_string_st *string;
1394
1395   string= memcached_string_create(memc, NULL, INT64_MAX);
1396   assert(string == NULL);
1397
1398   return 0;
1399 }
1400
1401 uint8_t string_alloc_append(memcached_st *memc)
1402 {
1403   unsigned int x;
1404   char buffer[SMALL_STRING_LEN];
1405   memcached_string_st *string;
1406
1407   /* Ring the bell! */
1408   memset(buffer, 6, SMALL_STRING_LEN);
1409
1410   string= memcached_string_create(memc, NULL, 100);
1411   assert(string);
1412
1413   for (x= 0; x < 1024; x++)
1414   {
1415     memcached_return rc;
1416     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1417     assert(rc == MEMCACHED_SUCCESS);
1418   }
1419   memcached_string_free(string);
1420
1421   return 0;
1422 }
1423
1424 uint8_t string_alloc_append_toobig(memcached_st *memc)
1425 {
1426   memcached_return rc;
1427   unsigned int x;
1428   char buffer[SMALL_STRING_LEN];
1429   memcached_string_st *string;
1430
1431   /* Ring the bell! */
1432   memset(buffer, 6, SMALL_STRING_LEN);
1433
1434   string= memcached_string_create(memc, NULL, 100);
1435   assert(string);
1436
1437   for (x= 0; x < 1024; x++)
1438   {
1439     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1440     assert(rc == MEMCACHED_SUCCESS);
1441   }
1442   rc= memcached_string_append(string, buffer, INT64_MAX);
1443   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
1444   memcached_string_free(string);
1445
1446   return 0;
1447 }
1448
1449 uint8_t cleanup_pairs(memcached_st *memc)
1450 {
1451   pairs_free(global_pairs);
1452
1453   return 0;
1454 }
1455
1456 uint8_t generate_data(memcached_st *memc)
1457 {
1458   unsigned long long x;
1459   global_pairs= pairs_generate(GLOBAL_COUNT);
1460   execute_set(memc, global_pairs, GLOBAL_COUNT);
1461
1462   for (x= 0; x < GLOBAL_COUNT; x++)
1463   {
1464     global_keys[x]= global_pairs[x].key;
1465     global_keys_length[x]=  global_pairs[x].key_length;
1466   }
1467
1468   return 0;
1469 }
1470
1471 uint8_t get_read(memcached_st *memc)
1472 {
1473   unsigned int x;
1474   memcached_return rc;
1475
1476   {
1477     char *return_value;
1478     size_t return_value_length;
1479     uint16_t flags;
1480
1481     for (x= 0; x < GLOBAL_COUNT; x++)
1482     {
1483       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
1484                                   &return_value_length, &flags, &rc);
1485       /*
1486       assert(return_value);
1487       assert(rc == MEMCACHED_SUCCESS);
1488     */
1489       if (rc == MEMCACHED_SUCCESS && return_value)
1490         free(return_value);
1491     }
1492   }
1493
1494   return 0;
1495 }
1496
1497 uint8_t mget_read(memcached_st *memc)
1498 {
1499   memcached_return rc;
1500
1501   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1502   assert(rc == MEMCACHED_SUCCESS);
1503   /* Turn this into a help function */
1504   {
1505     char return_key[MEMCACHED_MAX_KEY];
1506     size_t return_key_length;
1507     char *return_value;
1508     size_t return_value_length;
1509     uint16_t flags;
1510
1511     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1512                                           &return_value_length, &flags, &rc)))
1513     {
1514       assert(return_value);
1515       assert(rc == MEMCACHED_SUCCESS);
1516       free(return_value);
1517     }
1518   }
1519
1520   return 0;
1521 }
1522
1523 uint8_t mget_read_result(memcached_st *memc)
1524 {
1525   memcached_return rc;
1526
1527   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1528   assert(rc == MEMCACHED_SUCCESS);
1529   /* Turn this into a help function */
1530   {
1531     memcached_result_st results_obj;
1532     memcached_result_st *results;
1533
1534     results= memcached_result_create(memc, &results_obj);
1535
1536     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1537     {
1538       assert(results);
1539       assert(rc == MEMCACHED_SUCCESS);
1540     }
1541
1542     memcached_result_free(&results_obj);
1543   }
1544
1545   return 0;
1546 }
1547
1548 uint8_t free_data(memcached_st *memc)
1549 {
1550   pairs_free(global_pairs);
1551
1552   return 0;
1553 }
1554
1555 uint8_t add_host_test1(memcached_st *memc)
1556 {
1557   unsigned int x;
1558   memcached_return rc;
1559   char servername[]= "0.example.com";
1560   memcached_server_st *servers;
1561
1562   servers= memcached_server_list_append(NULL, servername, 400, &rc);
1563   assert(servers);
1564   assert(1 == memcached_server_list_count(servers));
1565
1566   for (x= 2; x < 20; x++)
1567   {
1568     char buffer[SMALL_STRING_LEN];
1569
1570     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1571     servers= memcached_server_list_append(servers, buffer, 401,
1572                                      &rc);
1573     assert(rc == MEMCACHED_SUCCESS);
1574     assert(x == memcached_server_list_count(servers));
1575   }
1576
1577   rc= memcached_server_push(memc, servers);
1578   assert(rc == MEMCACHED_SUCCESS);
1579   rc= memcached_server_push(memc, servers);
1580   assert(rc == MEMCACHED_SUCCESS);
1581
1582   memcached_server_list_free(servers);
1583
1584   return 0;
1585 }
1586
1587 memcached_return pre_nonblock(memcached_st *memc)
1588 {
1589   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1590
1591   return MEMCACHED_SUCCESS;
1592 }
1593
1594 memcached_return pre_md5(memcached_st *memc)
1595 {
1596   memcached_hash value= MEMCACHED_HASH_MD5;
1597   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1598
1599   return MEMCACHED_SUCCESS;
1600 }
1601
1602 memcached_return pre_crc(memcached_st *memc)
1603 {
1604   memcached_hash value= MEMCACHED_HASH_CRC;
1605   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1606
1607   return MEMCACHED_SUCCESS;
1608 }
1609
1610 memcached_return pre_hsieh(memcached_st *memc)
1611 {
1612   memcached_hash value= MEMCACHED_HASH_HSIEH;
1613   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1614
1615   return MEMCACHED_SUCCESS;
1616 }
1617
1618 memcached_return pre_hash_fnv1_64(memcached_st *memc)
1619 {
1620   memcached_hash value= MEMCACHED_HASH_FNV1_64;
1621   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1622
1623   return MEMCACHED_SUCCESS;
1624 }
1625
1626 memcached_return pre_hash_fnv1a_64(memcached_st *memc)
1627 {
1628   memcached_hash value= MEMCACHED_HASH_FNV1A_64;
1629   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1630
1631   return MEMCACHED_SUCCESS;
1632 }
1633
1634 memcached_return pre_hash_fnv1_32(memcached_st *memc)
1635 {
1636   memcached_hash value= MEMCACHED_HASH_FNV1_32;
1637   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1638
1639   return MEMCACHED_SUCCESS;
1640 }
1641
1642 memcached_return pre_hash_fnv1a_32(memcached_st *memc)
1643 {
1644   memcached_hash value= MEMCACHED_HASH_FNV1A_32;
1645   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1646
1647   return MEMCACHED_SUCCESS;
1648 }
1649
1650 memcached_return pre_hash_ketama(memcached_st *memc)
1651 {
1652   memcached_hash value= MEMCACHED_HASH_KETAMA;
1653   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1654
1655   return MEMCACHED_SUCCESS;
1656 }
1657
1658 memcached_return enable_consistent(memcached_st *memc)
1659 {
1660   memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;
1661   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, &value);
1662
1663   return MEMCACHED_SUCCESS;
1664 }
1665
1666 memcached_return enable_cas(memcached_st *memc)
1667 {
1668   unsigned int set= 1;
1669
1670   memcached_version(memc);
1671
1672   if (memc->hosts[0].major_version >= 1 &&
1673       memc->hosts[0].minor_version >= 2 &&
1674       memc->hosts[0].micro_version >= 4)
1675   {
1676     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
1677
1678     return MEMCACHED_SUCCESS;
1679   }
1680
1681   return MEMCACHED_FAILURE;
1682 }
1683
1684 memcached_return check_for_1_2_3(memcached_st *memc)
1685 {
1686   memcached_version(memc);
1687
1688   if (memc->hosts[0].major_version >= 1 &&
1689       memc->hosts[0].minor_version >= 2 &&
1690       memc->hosts[0].micro_version >= 4)
1691     return MEMCACHED_SUCCESS;
1692
1693   return MEMCACHED_FAILURE;
1694 }
1695
1696 memcached_return pre_unix_socket(memcached_st *memc)
1697 {
1698   memcached_return rc;
1699   struct stat buf;
1700
1701   memcached_server_list_free(memc->hosts);
1702   memc->hosts= NULL;
1703   memc->number_of_hosts= 0;
1704
1705   if (stat("/tmp/memcached.socket", &buf))
1706     return MEMCACHED_FAILURE;
1707
1708   rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");
1709
1710   return rc;
1711 }
1712
1713 memcached_return pre_udp(memcached_st *memc)
1714 {
1715   memcached_return rc;
1716
1717   memcached_server_list_free(memc->hosts);
1718   memc->hosts= NULL;
1719   memc->number_of_hosts= 0;
1720
1721   if (0)
1722     return MEMCACHED_FAILURE;
1723
1724   rc= memcached_server_add_udp(memc, "localhost", MEMCACHED_DEFAULT_PORT);
1725
1726   return rc;
1727 }
1728
1729 memcached_return pre_nodelay(memcached_st *memc)
1730 {
1731   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1732   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
1733
1734   return MEMCACHED_SUCCESS;
1735 }
1736
1737 memcached_return poll_timeout(memcached_st *memc)
1738 {
1739   int32_t timeout;
1740
1741   timeout= 100;
1742
1743   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
1744
1745   timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
1746
1747   assert(timeout == 100);
1748
1749   return MEMCACHED_SUCCESS;
1750 }
1751
1752
1753 /* Clean the server before beginning testing */
1754 test_st tests[] ={
1755   {"flush", 0, flush_test },
1756   {"init", 0, init_test },
1757   {"allocation", 0, allocation_test },
1758   {"clone_test", 0, clone_test },
1759   {"error", 0, error_test },
1760   {"set", 0, set_test },
1761   {"set2", 0, set_test2 },
1762   {"set3", 0, set_test3 },
1763   {"add", 0, add_test },
1764   {"replace", 0, replace_test },
1765   {"delete", 1, delete_test },
1766   {"get", 1, get_test },
1767   {"get2", 0, get_test2 },
1768   {"get3", 0, get_test3 },
1769   {"get4", 0, get_test4 },
1770   {"stats_servername", 0, stats_servername_test },
1771   {"increment", 0, increment_test },
1772   {"decrement", 0, decrement_test },
1773   {"quit", 0, quit_test },
1774   {"mget", 1, mget_test },
1775   {"mget_result", 1, mget_result_test },
1776   {"mget_result_alloc", 1, mget_result_alloc_test },
1777   {"get_stats", 0, get_stats },
1778   {"add_host_test", 0, add_host_test },
1779   {"get_stats_keys", 0, get_stats_keys },
1780   {"behavior_test", 0, get_stats_keys },
1781   {0, 0, 0}
1782 };
1783
1784 test_st string_tests[] ={
1785   {"string static with null", 0, string_static_null },
1786   {"string alloc with null", 0, string_alloc_null },
1787   {"string alloc with 1K", 0, string_alloc_with_size },
1788   {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
1789   {"string append", 0, string_alloc_append },
1790   {"string append failure (too big)", 0, string_alloc_append_toobig },
1791   {0, 0, 0}
1792 };
1793
1794 test_st result_tests[] ={
1795   {"result static", 0, result_static},
1796   {"result alloc", 0, result_alloc},
1797   {0, 0, 0}
1798 };
1799
1800 test_st version_1_2_3[] ={
1801   {"append", 0, append_test },
1802   {"prepend", 0, prepend_test },
1803   {"cas", 0, cas_test },
1804   {"cas2", 0, cas2_test },
1805   {"append_binary", 0, append_binary_test },
1806   {0, 0, 0}
1807 };
1808
1809 test_st user_tests[] ={
1810   {"user_supplied_bug1", 0, user_supplied_bug1 },
1811   {"user_supplied_bug2", 0, user_supplied_bug2 },
1812   {"user_supplied_bug3", 0, user_supplied_bug3 },
1813   {"user_supplied_bug4", 0, user_supplied_bug4 },
1814   {"user_supplied_bug5", 1, user_supplied_bug5 },
1815   {"user_supplied_bug6", 1, user_supplied_bug6 },
1816   {"user_supplied_bug7", 1, user_supplied_bug7 },
1817   {"user_supplied_bug8", 1, user_supplied_bug8 },
1818   {0, 0, 0}
1819 };
1820
1821 test_st generate_tests[] ={
1822   {"generate_data", 0, generate_data },
1823   {"get_read", 0, get_read },
1824   {"mget_read", 0, mget_read },
1825   {"mget_read_result", 0, mget_read_result },
1826   {"cleanup", 0, cleanup_pairs },
1827   {0, 0, 0}
1828 };
1829
1830
1831 collection_st collection[] ={
1832   {"block", 0, 0, tests},
1833   {"nonblock", pre_nonblock, 0, tests},
1834   {"nodelay", pre_nodelay, 0, tests},
1835   {"md5", pre_md5, 0, tests},
1836   {"crc", pre_crc, 0, tests},
1837   {"hsieh", pre_hsieh, 0, tests},
1838   {"fnv1_64", pre_hash_fnv1_64, 0, tests},
1839   {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
1840   {"fnv1_32", pre_hash_fnv1_32, 0, tests},
1841   {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
1842   {"ketama", pre_hash_ketama, 0, tests},
1843   {"unix_socket", pre_unix_socket, 0, tests},
1844   {"unix_socket_nodelay", pre_nodelay, 0, tests},
1845   {"poll_timeout", poll_timeout, 0, tests},
1846   {"gets", enable_cas, 0, tests},
1847   {"consistent", enable_consistent, 0, tests},
1848 //  {"udp", pre_udp, 0, tests},
1849   {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
1850   {"string", 0, 0, string_tests},
1851   {"result", 0, 0, result_tests},
1852   {"user", 0, 0, user_tests},
1853   {"generate", 0, 0, generate_tests},
1854   {"generate_hsieh", pre_hsieh, 0, generate_tests},
1855   {"generate_nonblock", pre_nonblock, 0, generate_tests},
1856   {0, 0, 0, 0}
1857 };
1858
1859 collection_st *gets_collections(void)
1860 {
1861   return collection;
1862 }