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

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