git.m6w6.name Git - awesomized/libmemcached/blob - tests/function.c

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