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