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