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

   1 /*
   2   Sample test application.
   3 */
   4 #include <assert.h>
   5 #include <memcached.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <sys/time.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <unistd.h>
  13 #include <time.h>
  14 #include "../lib/common.h"
  15 #include "../src/generator.h"
  16 #include "../src/execute.h"
  17
  18 #include "test.h"
  19
  20 #define GLOBAL_COUNT 100000
  21 static pairs_st *global_pairs;
  22 static char *global_keys[GLOBAL_COUNT];
  23 static size_t global_keys_length[GLOBAL_COUNT];
  24
  25 uint8_t init_test(memcached_st *not_used)
  26 {
  27   memcached_st memc;
  28
  29   (void)memcached_create(&memc);
  30   memcached_free(&memc);
  31
  32   return 0;
  33 }
  34
  35 uint8_t allocation_test(memcached_st *not_used)
  36 {
  37   memcached_st *memc;
  38   memc= memcached_create(NULL);
  39   assert(memc);
  40   memcached_free(memc);
  41
  42   return 0;
  43 }
  44
  45 uint8_t clone_test(memcached_st *memc)
  46 {
  47   /* All null? */
  48   {
  49     memcached_st *clone;
  50     clone= memcached_clone(NULL, NULL);
  51     assert(clone);
  52     memcached_free(clone);
  53   }
  54
  55   /* Can we init from null? */
  56   {
  57     memcached_st *clone;
  58     clone= memcached_clone(NULL, memc);
  59     assert(clone);
  60     memcached_free(clone);
  61   }
  62
  63   /* Can we init from struct? */
  64   {
  65     memcached_st declared_clone;
  66     memcached_st *clone;
  67     clone= memcached_clone(&declared_clone, NULL);
  68     assert(clone);
  69     memcached_free(clone);
  70   }
  71
  72   /* Can we init from struct? */
  73   {
  74     memcached_st declared_clone;
  75     memcached_st *clone;
  76     clone= memcached_clone(&declared_clone, memc);
  77     assert(clone);
  78     memcached_free(clone);
  79   }
  80
  81   return 0;
  82 }
  83
  84 uint8_t connection_test(memcached_st *memc)
  85 {
  86   memcached_return rc;
  87
  88   rc= memcached_server_add(memc, "localhost", 0);
  89   assert(rc == MEMCACHED_SUCCESS);
  90
  91   return 0;
  92 }
  93
  94 uint8_t error_test(memcached_st *memc)
  95 {
  96   memcached_return rc;
  97
  98   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
  99   {
 100     printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
 101   }
 102
 103   return 0;
 104 }
 105
 106 uint8_t set_test(memcached_st *memc)
 107 {
 108   memcached_return rc;
 109   char *key= "foo";
 110   char *value= "when we sanitize";
 111
 112   rc= memcached_set(memc, key, strlen(key),
 113                     value, strlen(value),
 114                     (time_t)0, (uint16_t)0);
 115   assert(rc == MEMCACHED_SUCCESS);
 116
 117   return 0;
 118 }
 119
 120 uint8_t add_test(memcached_st *memc)
 121 {
 122   memcached_return rc;
 123   char *key= "foo";
 124   char *value= "when we sanitize";
 125
 126   rc= memcached_add(memc, key, strlen(key),
 127                     value, strlen(value),
 128                     (time_t)0, (uint16_t)0);
 129   assert(rc == MEMCACHED_NOTSTORED);
 130
 131   return 0;
 132 }
 133
 134 uint8_t replace_test(memcached_st *memc)
 135 {
 136   memcached_return rc;
 137   char *key= "foo";
 138   char *value= "when we sanitize";
 139
 140   rc= memcached_replace(memc, key, strlen(key),
 141                     value, strlen(value),
 142                     (time_t)0, (uint16_t)0);
 143   assert(rc == MEMCACHED_SUCCESS);
 144
 145   return 0;
 146 }
 147
 148 uint8_t delete_test(memcached_st *memc)
 149 {
 150   memcached_return rc;
 151   char *key= "foo";
 152   char *value= "when we sanitize";
 153
 154   rc= memcached_set(memc, key, strlen(key),
 155                     value, strlen(value),
 156                     (time_t)0, (uint16_t)0);
 157   assert(rc == MEMCACHED_SUCCESS);
 158
 159   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 160   assert(rc == MEMCACHED_SUCCESS);
 161
 162   return 0;
 163 }
 164
 165 uint8_t flush_test(memcached_st *memc)
 166 {
 167   memcached_return rc;
 168
 169   rc= memcached_flush(memc, 0);
 170   assert(rc == MEMCACHED_SUCCESS);
 171
 172   return 0;
 173 }
 174
 175 uint8_t get_test(memcached_st *memc)
 176 {
 177   memcached_return rc;
 178   char *key= "foo";
 179   char *string;
 180   size_t string_length;
 181   uint16_t flags;
 182
 183   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 184   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND);
 185
 186   string= memcached_get(memc, key, strlen(key),
 187                         &string_length, &flags, &rc);
 188
 189   assert(rc == MEMCACHED_NOTFOUND);
 190   assert(string_length ==  0);
 191   assert(!string);
 192
 193   return 0;
 194 }
 195
 196 uint8_t get_test2(memcached_st *memc)
 197 {
 198   memcached_return rc;
 199   char *key= "foo";
 200   char *value= "when we sanitize";
 201   char *string;
 202   size_t string_length;
 203   uint16_t flags;
 204
 205   rc= memcached_set(memc, key, strlen(key),
 206                     value, strlen(value),
 207                     (time_t)0, (uint16_t)0);
 208   assert(rc == MEMCACHED_SUCCESS);
 209
 210   string= memcached_get(memc, key, strlen(key),
 211                         &string_length, &flags, &rc);
 212
 213   assert(string);
 214   assert(rc == MEMCACHED_SUCCESS);
 215   assert(string_length == strlen(value));
 216   assert(!memcmp(string, value, string_length));
 217
 218   free(string);
 219
 220   return 0;
 221 }
 222
 223 uint8_t set_test2(memcached_st *memc)
 224 {
 225   memcached_return rc;
 226   char *key= "foo";
 227   char *value= "train in the brain";
 228   size_t value_length= strlen(value);
 229   unsigned int x;
 230
 231   for (x= 0; x < 10; x++)
 232   {
 233     rc= memcached_set(memc, key, strlen(key),
 234                       value, value_length,
 235                       (time_t)0, (uint16_t)0);
 236     assert(rc == MEMCACHED_SUCCESS);
 237   }
 238
 239   return 0;
 240 }
 241
 242 uint8_t set_test3(memcached_st *memc)
 243 {
 244   memcached_return rc;
 245   char *key= "foo";
 246   char *value;
 247   size_t value_length= 8191;
 248   unsigned int x;
 249
 250   value = (char*)malloc(value_length);
 251   assert(value);
 252
 253   for (x= 0; x < value_length; x++)
 254     value[x] = (char) (x % 127);
 255
 256   for (x= 0; x < 1; x++)
 257   {
 258     rc= memcached_set(memc, key, strlen(key),
 259                       value, value_length,
 260                       (time_t)0, (uint16_t)0);
 261     assert(rc == MEMCACHED_SUCCESS);
 262   }
 263
 264   free(value);
 265
 266   return 0;
 267 }
 268
 269 uint8_t get_test3(memcached_st *memc)
 270 {
 271   memcached_return rc;
 272   char *key= "foo";
 273   char *value;
 274   size_t value_length= 8191;
 275   char *string;
 276   size_t string_length;
 277   uint16_t flags;
 278   int x;
 279
 280   value = (char*)malloc(value_length);
 281   assert(value);
 282
 283   for (x= 0; x < value_length; x++)
 284     value[x] = (char) (x % 127);
 285
 286   rc= memcached_set(memc, key, strlen(key),
 287                     value, value_length,
 288                     (time_t)0, (uint16_t)0);
 289   assert(rc == MEMCACHED_SUCCESS);
 290
 291   string= memcached_get(memc, key, strlen(key),
 292                         &string_length, &flags, &rc);
 293
 294   assert(rc == MEMCACHED_SUCCESS);
 295   assert(string);
 296   assert(string_length == value_length);
 297   assert(!memcmp(string, value, string_length));
 298
 299   free(string);
 300   free(value);
 301
 302   return 0;
 303 }
 304
 305 uint8_t get_test4(memcached_st *memc)
 306 {
 307   memcached_return rc;
 308   char *key= "foo";
 309   char *value;
 310   size_t value_length= 8191;
 311   char *string;
 312   size_t string_length;
 313   uint16_t flags;
 314   int x;
 315
 316   value = (char*)malloc(value_length);
 317   assert(value);
 318
 319   for (x= 0; x < value_length; x++)
 320     value[x] = (char) (x % 127);
 321
 322   rc= memcached_set(memc, key, strlen(key),
 323                     value, value_length,
 324                     (time_t)0, (uint16_t)0);
 325   assert(rc == MEMCACHED_SUCCESS);
 326
 327   for (x= 0; x < 10; x++)
 328   {
 329     string= memcached_get(memc, key, strlen(key),
 330                           &string_length, &flags, &rc);
 331
 332     assert(rc == MEMCACHED_SUCCESS);
 333     assert(string);
 334     assert(string_length == value_length);
 335     assert(!memcmp(string, value, string_length));
 336     free(string);
 337   }
 338
 339   free(value);
 340
 341   return 0;
 342 }
 343
 344 uint8_t stats_servername_test(memcached_st *memc)
 345 {
 346   memcached_return rc;
 347   memcached_stat_st stat;
 348   rc= memcached_stat_servername(&stat, NULL,
 349                                  "localhost",
 350                                  MEMCACHED_DEFAULT_PORT);
 351
 352   return 0;
 353 }
 354
 355 uint8_t increment_test(memcached_st *memc)
 356 {
 357   unsigned int new_number;
 358   memcached_return rc;
 359   char *key= "number";
 360   char *value= "0";
 361
 362   rc= memcached_set(memc, key, strlen(key),
 363                     value, strlen(value),
 364                     (time_t)0, (uint16_t)0);
 365   assert(rc == MEMCACHED_SUCCESS);
 366
 367   rc= memcached_increment(memc, key, strlen(key),
 368                           1, &new_number);
 369   assert(rc == MEMCACHED_SUCCESS);
 370   assert(new_number == 1);
 371
 372   rc= memcached_increment(memc, key, strlen(key),
 373                           1, &new_number);
 374   assert(rc == MEMCACHED_SUCCESS);
 375   assert(new_number == 2);
 376
 377   return 0;
 378 }
 379
 380 uint8_t decrement_test(memcached_st *memc)
 381 {
 382   unsigned int new_number;
 383   memcached_return rc;
 384   char *key= "number";
 385   char *value= "3";
 386
 387   rc= memcached_set(memc, key, strlen(key),
 388                     value, strlen(value),
 389                     (time_t)0, (uint16_t)0);
 390   assert(rc == MEMCACHED_SUCCESS);
 391
 392   rc= memcached_decrement(memc, key, strlen(key),
 393                           1, &new_number);
 394   assert(rc == MEMCACHED_SUCCESS);
 395   assert(new_number == 2);
 396
 397   rc= memcached_decrement(memc, key, strlen(key),
 398                           1, &new_number);
 399   assert(rc == MEMCACHED_SUCCESS);
 400   assert(new_number == 1);
 401
 402   return 0;
 403 }
 404
 405 uint8_t quit_test(memcached_st *memc)
 406 {
 407   memcached_return rc;
 408   char *key= "fudge";
 409   char *value= "sanford and sun";
 410
 411   rc= memcached_set(memc, key, strlen(key),
 412                     value, strlen(value),
 413                     (time_t)10, (uint16_t)3);
 414   assert(rc == MEMCACHED_SUCCESS);
 415   memcached_quit(memc);
 416
 417   rc= memcached_set(memc, key, strlen(key),
 418                     value, strlen(value),
 419                     (time_t)50, (uint16_t)9);
 420   assert(rc == MEMCACHED_SUCCESS);
 421
 422   return 0;
 423 }
 424
 425 uint8_t mget_result_test(memcached_st *memc)
 426 {
 427   memcached_return rc;
 428   char *keys[]= {"fudge", "son", "food"};
 429   size_t key_length[]= {5, 3, 4};
 430   unsigned int x;
 431
 432   memcached_result_st results_obj;
 433   memcached_result_st *results;
 434
 435   results= memcached_result_create(memc, &results_obj);
 436   assert(results);
 437   assert(&results_obj == results);
 438
 439   /* We need to empty the server before continueing test */
 440   rc= memcached_flush(memc, 0);
 441   assert(rc == MEMCACHED_SUCCESS);
 442
 443   rc= memcached_mget(memc, keys, key_length, 3);
 444   assert(rc == MEMCACHED_SUCCESS);
 445
 446   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 447   {
 448     assert(results);
 449   }
 450   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 451   assert(!results);
 452   assert(rc == MEMCACHED_NOTFOUND);
 453
 454   for (x= 0; x < 3; x++)
 455   {
 456     rc= memcached_set(memc, keys[x], key_length[x],
 457                       keys[x], key_length[x],
 458                       (time_t)50, (uint16_t)9);
 459     assert(rc == MEMCACHED_SUCCESS);
 460   }
 461
 462   rc= memcached_mget(memc, keys, key_length, 3);
 463   assert(rc == MEMCACHED_SUCCESS);
 464
 465   while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
 466   {
 467     assert(results);
 468     assert(&results_obj == results);
 469     assert(rc == MEMCACHED_SUCCESS);
 470     assert(memcached_result_key_length(results) == memcached_result_length(results));
 471     assert(!memcmp(memcached_result_key_value(results),
 472                    memcached_result_value(results),
 473                    memcached_result_length(results)));
 474   }
 475
 476   memcached_result_free(&results_obj);
 477
 478   return 0;
 479 }
 480
 481 uint8_t mget_result_alloc_test(memcached_st *memc)
 482 {
 483   memcached_return rc;
 484   char *keys[]= {"fudge", "son", "food"};
 485   size_t key_length[]= {5, 3, 4};
 486   unsigned int x;
 487
 488   memcached_result_st *results;
 489
 490   /* We need to empty the server before continueing test */
 491   rc= memcached_flush(memc, 0);
 492   assert(rc == MEMCACHED_SUCCESS);
 493
 494   rc= memcached_mget(memc, keys, key_length, 3);
 495   assert(rc == MEMCACHED_SUCCESS);
 496
 497   while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
 498   {
 499     assert(results);
 500   }
 501   assert(!results);
 502   assert(rc == MEMCACHED_NOTFOUND);
 503
 504   for (x= 0; x < 3; x++)
 505   {
 506     rc= memcached_set(memc, keys[x], key_length[x],
 507                       keys[x], key_length[x],
 508                       (time_t)50, (uint16_t)9);
 509     assert(rc == MEMCACHED_SUCCESS);
 510   }
 511
 512   rc= memcached_mget(memc, keys, key_length, 3);
 513   assert(rc == MEMCACHED_SUCCESS);
 514
 515   x= 0;
 516   while ((results= memcached_fetch_result(memc, NULL, &rc)))
 517   {
 518     assert(results);
 519     assert(rc == MEMCACHED_SUCCESS);
 520     assert(memcached_result_key_length(results) == memcached_result_length(results));
 521     assert(!memcmp(memcached_result_key_value(results),
 522                    memcached_result_value(results),
 523                    memcached_result_length(results)));
 524     memcached_result_free(results);
 525     x++;
 526   }
 527
 528   return 0;
 529 }
 530
 531 uint8_t mget_test(memcached_st *memc)
 532 {
 533   memcached_return rc;
 534   char *keys[]= {"fudge", "son", "food"};
 535   size_t key_length[]= {5, 3, 4};
 536   unsigned int x;
 537   uint16_t flags;
 538
 539   char return_key[MEMCACHED_MAX_KEY];
 540   size_t return_key_length;
 541   char *return_value;
 542   size_t return_value_length;
 543
 544   /* We need to empty the server before continueing test */
 545   rc= memcached_flush(memc, 0);
 546   assert(rc == MEMCACHED_SUCCESS);
 547
 548   rc= memcached_mget(memc, keys, key_length, 3);
 549   assert(rc == MEMCACHED_SUCCESS);
 550
 551   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 552                       &return_value_length, &flags, &rc)) != NULL)
 553   {
 554     assert(return_value);
 555   }
 556   assert(!return_value);
 557   assert(return_value_length == 0);
 558   assert(rc == MEMCACHED_NOTFOUND);
 559
 560   for (x= 0; x < 3; x++)
 561   {
 562     rc= memcached_set(memc, keys[x], key_length[x],
 563                       keys[x], key_length[x],
 564                       (time_t)50, (uint16_t)9);
 565     assert(rc == MEMCACHED_SUCCESS);
 566   }
 567
 568   rc= memcached_mget(memc, keys, key_length, 3);
 569   assert(rc == MEMCACHED_SUCCESS);
 570
 571   x= 0;
 572   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 573                                         &return_value_length, &flags, &rc)))
 574   {
 575     assert(return_value);
 576     assert(rc == MEMCACHED_SUCCESS);
 577     assert(return_key_length == return_value_length);
 578     assert(!memcmp(return_value, return_key, return_value_length));
 579     free(return_value);
 580     x++;
 581   }
 582
 583   return 0;
 584 }
 585
 586 uint8_t get_stats_keys(memcached_st *memc)
 587 {
 588  char **list;
 589  char **ptr;
 590  memcached_stat_st stat;
 591  memcached_return rc;
 592
 593  list= memcached_stat_get_keys(memc, &stat, &rc);
 594  assert(rc == MEMCACHED_SUCCESS);
 595  for (ptr= list; *ptr; ptr++)
 596    printf("Found key %s\n", *ptr);
 597  fflush(stdout);
 598
 599  free(list);
 600
 601  return 0;
 602 }
 603
 604 uint8_t get_stats(memcached_st *memc)
 605 {
 606  unsigned int x;
 607  char **list;
 608  char **ptr;
 609  memcached_return rc;
 610  memcached_stat_st *stat;
 611
 612  stat= memcached_stat(memc, NULL, &rc);
 613  assert(rc == MEMCACHED_SUCCESS);
 614
 615  assert(rc == MEMCACHED_SUCCESS);
 616  assert(stat);
 617
 618  for (x= 0; x < memcached_server_count(memc); x++)
 619  {
 620    list= memcached_stat_get_keys(memc, &stat[x], &rc);
 621    assert(rc == MEMCACHED_SUCCESS);
 622    for (ptr= list; *ptr; ptr++)
 623      printf("Found key %s\n", *ptr);
 624
 625    free(list);
 626  }
 627
 628  memcached_stat_free(NULL, stat);
 629
 630   return 0;
 631 }
 632
 633 uint8_t add_host_test(memcached_st *memc)
 634 {
 635   unsigned int x;
 636   memcached_server_st *servers;
 637   memcached_return rc;
 638   char servername[]= "0.example.com";
 639
 640   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 641   assert(servers);
 642   assert(1 == memcached_server_list_count(servers));
 643
 644   for (x= 2; x < 20; x++)
 645   {
 646     char buffer[SMALL_STRING_LEN];
 647
 648     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 649     servers= memcached_server_list_append(servers, buffer, 401,
 650                                      &rc);
 651     assert(rc == MEMCACHED_SUCCESS);
 652     assert(x == memcached_server_list_count(servers));
 653   }
 654
 655   rc= memcached_server_push(memc, servers);
 656   assert(rc == MEMCACHED_SUCCESS);
 657   rc= memcached_server_push(memc, servers);
 658   assert(rc == MEMCACHED_SUCCESS);
 659
 660   memcached_server_list_free(servers);
 661
 662   return 0;
 663 }
 664
 665 /* We don't test the behavior itself, we test the switches */
 666 uint8_t behavior_test(memcached_st *memc)
 667 {
 668   unsigned long long value;
 669   unsigned int set= 1;
 670
 671   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 672   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 673   assert(value == 1);
 674
 675   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 676   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 677   assert(value == 1);
 678
 679   set= MEMCACHED_HASH_MD5;
 680   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
 681   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 682   assert(value == MEMCACHED_HASH_MD5);
 683
 684   set= 0;
 685
 686   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 687   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 688   assert(value == 0);
 689
 690   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 691   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 692   assert(value == 0);
 693
 694   set= MEMCACHED_HASH_DEFAULT;
 695   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
 696   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 697   assert(value == MEMCACHED_HASH_DEFAULT);
 698
 699   set= MEMCACHED_HASH_CRC;
 700   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
 701   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 702   assert(value == MEMCACHED_HASH_CRC);
 703
 704   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
 705   assert(value > 0);
 706
 707   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 708   assert(value > 0);
 709
 710   return 0;
 711 }
 712
 713 /* Test case provided by Cal Haldenbrand */
 714 uint8_t user_supplied_bug1(memcached_st *memc)
 715 {
 716   unsigned int setter= 1;
 717   unsigned int x;
 718
 719   unsigned long long total= 0;
 720   int size= 0;
 721   char key[10];
 722   char randomstuff[6 * 1024];
 723   memcached_return rc;
 724
 725   memset(randomstuff, 0, 6 * 1024);
 726
 727   /* We just keep looking at the same values over and over */
 728   srandom(10);
 729
 730   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 731   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 732
 733
 734   /* add key */
 735   for (x= 0 ; total < 20 * 1024576 ; x++ )
 736   {
 737     unsigned int j= 0;
 738
 739     size= (rand() % ( 5 * 1024 ) ) + 400;
 740     memset(randomstuff, 0, 6 * 1024);
 741     assert(size < 6 * 1024); /* Being safe here */
 742
 743     for (j= 0 ; j < size ;j++)
 744       randomstuff[j] = (char) (rand() % 26) + 97;
 745
 746     total += size;
 747     sprintf(key, "%d", x);
 748     rc = memcached_set(memc, key, strlen(key),
 749                        randomstuff, strlen(randomstuff), 10, 0);
 750     /* If we fail, lets try again */
 751     if (rc != MEMCACHED_SUCCESS)
 752       rc = memcached_set(memc, key, strlen(key),
 753                          randomstuff, strlen(randomstuff), 10, 0);
 754     assert(rc == MEMCACHED_SUCCESS);
 755   }
 756
 757   return 0;
 758 }
 759
 760 /* Test case provided by Cal Haldenbrand */
 761 uint8_t user_supplied_bug2(memcached_st *memc)
 762 {
 763   int errors;
 764   unsigned int setter;
 765   unsigned int x;
 766   unsigned long long total;
 767
 768   setter= 1;
 769   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 770   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 771 #ifdef NOT_YET
 772   setter = 20 * 1024576;
 773   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
 774   setter = 20 * 1024576;
 775   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
 776   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
 777   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 778
 779   for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
 780 #endif
 781
 782   for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
 783   {
 784     memcached_return rc= MEMCACHED_SUCCESS;
 785     char buffer[SMALL_STRING_LEN];
 786     uint16_t flags= 0;
 787     size_t val_len= 0;
 788     char *getval;
 789
 790     memset(buffer, 0, SMALL_STRING_LEN);
 791
 792     snprintf(buffer, SMALL_STRING_LEN, "%u", x);
 793     getval= memcached_get(memc, buffer, strlen(buffer),
 794                            &val_len, &flags, &rc);
 795     if (rc != MEMCACHED_SUCCESS)
 796     {
 797       if (rc == MEMCACHED_NOTFOUND)
 798         errors++;
 799       else
 800         assert(0);
 801
 802       continue;
 803     }
 804     total+= val_len;
 805     errors= 0;
 806     free(getval);
 807   }
 808
 809   return 0;
 810 }
 811
 812 /* Do a large mget() over all the keys we think exist */
 813 #define KEY_COUNT 3000 // * 1024576
 814 uint8_t user_supplied_bug3(memcached_st *memc)
 815 {
 816   memcached_return rc;
 817   unsigned int setter;
 818   unsigned int x;
 819   char **keys;
 820   size_t key_lengths[KEY_COUNT];
 821
 822   setter= 1;
 823   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 824   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 825 #ifdef NOT_YET
 826   setter = 20 * 1024576;
 827   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
 828   setter = 20 * 1024576;
 829   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
 830   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
 831   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 832 #endif
 833
 834   keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
 835   assert(keys);
 836   memset(keys, 0, (sizeof(char *) * KEY_COUNT));
 837   for (x= 0; x < KEY_COUNT; x++)
 838   {
 839     char buffer[30];
 840
 841     snprintf(buffer, 30, "%u", x);
 842     keys[x]= strdup(buffer);
 843     key_lengths[x]= strlen(keys[x]);
 844   }
 845
 846   rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
 847   assert(rc == MEMCACHED_SUCCESS);
 848
 849   /* Turn this into a help function */
 850   {
 851     char return_key[MEMCACHED_MAX_KEY];
 852     size_t return_key_length;
 853     char *return_value;
 854     size_t return_value_length;
 855     uint16_t flags;
 856
 857     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 858                                           &return_value_length, &flags, &rc)))
 859     {
 860       assert(return_value);
 861       assert(rc == MEMCACHED_SUCCESS);
 862       free(return_value);
 863     }
 864   }
 865
 866   for (x= 0; x < KEY_COUNT; x++)
 867     free(keys[x]);
 868   free(keys);
 869
 870   return 0;
 871 }
 872
 873 /* Make sure we behave properly if server list has no values */
 874 uint8_t user_supplied_bug4(memcached_st *memc)
 875 {
 876   memcached_return rc;
 877   char *keys[]= {"fudge", "son", "food"};
 878   size_t key_length[]= {5, 3, 4};
 879   unsigned int x;
 880   uint16_t flags;
 881
 882   /* Here we free everything before running a bunch of mget tests */
 883   {
 884     memcached_server_list_free(memc->hosts);
 885     memc->hosts= NULL;
 886     memc->number_of_hosts= 0;
 887   }
 888
 889   char return_key[MEMCACHED_MAX_KEY];
 890   size_t return_key_length;
 891   char *return_value;
 892   size_t return_value_length;
 893
 894   /* We need to empty the server before continueing test */
 895   rc= memcached_flush(memc, 0);
 896   WATCHPOINT_ERROR(rc);
 897   assert(rc == MEMCACHED_NO_SERVERS);
 898
 899   rc= memcached_mget(memc, keys, key_length, 3);
 900   assert(rc == MEMCACHED_NO_SERVERS);
 901
 902   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 903                       &return_value_length, &flags, &rc)) != NULL)
 904   {
 905     assert(return_value);
 906   }
 907   assert(!return_value);
 908   assert(return_value_length == 0);
 909   assert(rc == MEMCACHED_NO_SERVERS);
 910
 911   WATCHPOINT;
 912   for (x= 0; x < 3; x++)
 913   {
 914     rc= memcached_set(memc, keys[x], key_length[x],
 915                       keys[x], key_length[x],
 916                       (time_t)50, (uint16_t)9);
 917     assert(rc == MEMCACHED_NO_SERVERS);
 918   }
 919
 920   WATCHPOINT;
 921   rc= memcached_mget(memc, keys, key_length, 3);
 922   assert(rc == MEMCACHED_NO_SERVERS);
 923   WATCHPOINT;
 924
 925   x= 0;
 926   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 927                                         &return_value_length, &flags, &rc)))
 928   {
 929     WATCHPOINT;
 930     assert(return_value);
 931     assert(rc == MEMCACHED_SUCCESS);
 932     assert(return_key_length == return_value_length);
 933     assert(!memcmp(return_value, return_key, return_value_length));
 934     free(return_value);
 935     x++;
 936   }
 937
 938   return 0;
 939 }
 940
 941 uint8_t result_static(memcached_st *memc)
 942 {
 943   memcached_result_st result;
 944   memcached_result_st *result_ptr;
 945
 946   result_ptr= memcached_result_create(memc, &result);
 947   assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
 948   assert(result_ptr);
 949   memcached_result_free(&result);
 950
 951   return 0;
 952 }
 953
 954 uint8_t result_alloc(memcached_st *memc)
 955 {
 956   memcached_result_st *result;
 957
 958   result= memcached_result_create(memc, NULL);
 959   assert(result);
 960   memcached_result_free(result);
 961
 962   return 0;
 963 }
 964
 965 uint8_t string_static_null(memcached_st *memc)
 966 {
 967   memcached_string_st string;
 968   memcached_string_st *string_ptr;
 969
 970   string_ptr= memcached_string_create(memc, &string, 0);
 971   assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
 972   assert(string_ptr);
 973   memcached_string_free(&string);
 974
 975   return 0;
 976 }
 977
 978 uint8_t string_alloc_null(memcached_st *memc)
 979 {
 980   memcached_string_st *string;
 981
 982   string= memcached_string_create(memc, NULL, 0);
 983   assert(string);
 984   memcached_string_free(string);
 985
 986   return 0;
 987 }
 988
 989 uint8_t string_alloc_with_size(memcached_st *memc)
 990 {
 991   memcached_string_st *string;
 992
 993   string= memcached_string_create(memc, NULL, 1024);
 994   assert(string);
 995   memcached_string_free(string);
 996
 997   return 0;
 998 }
 999
1000 uint8_t string_alloc_with_size_toobig(memcached_st *memc)
1001 {
1002   memcached_string_st *string;
1003
1004   string= memcached_string_create(memc, NULL, INT64_MAX);
1005   assert(string == NULL);
1006
1007   return 0;
1008 }
1009
1010 uint8_t string_alloc_append(memcached_st *memc)
1011 {
1012   unsigned int x;
1013   char buffer[SMALL_STRING_LEN];
1014   memcached_string_st *string;
1015
1016   /* Ring the bell! */
1017   memset(buffer, 6, SMALL_STRING_LEN);
1018
1019   string= memcached_string_create(memc, NULL, 100);
1020   assert(string);
1021
1022   for (x= 0; x < 1024; x++)
1023   {
1024     memcached_return rc;
1025     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1026     assert(rc == MEMCACHED_SUCCESS);
1027   }
1028   memcached_string_free(string);
1029
1030   return 0;
1031 }
1032
1033 uint8_t string_alloc_append_toobig(memcached_st *memc)
1034 {
1035   memcached_return rc;
1036   unsigned int x;
1037   char buffer[SMALL_STRING_LEN];
1038   memcached_string_st *string;
1039
1040   /* Ring the bell! */
1041   memset(buffer, 6, SMALL_STRING_LEN);
1042
1043   string= memcached_string_create(memc, NULL, 100);
1044   assert(string);
1045
1046   for (x= 0; x < 1024; x++)
1047   {
1048     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1049     assert(rc == MEMCACHED_SUCCESS);
1050   }
1051   rc= memcached_string_append(string, buffer, INT64_MAX);
1052   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
1053   memcached_string_free(string);
1054
1055   return 0;
1056 }
1057
1058 uint8_t generate_data(memcached_st *memc)
1059 {
1060   unsigned long long x;
1061   global_pairs= pairs_generate(GLOBAL_COUNT);
1062   execute_set(memc, global_pairs, GLOBAL_COUNT);
1063
1064   for (x= 0; x < GLOBAL_COUNT; x++)
1065   {
1066     global_keys[x]= global_pairs[x].key;
1067     global_keys_length[x]=  global_pairs[x].key_length;
1068   }
1069
1070   return 0;
1071 }
1072
1073 uint8_t get_read(memcached_st *memc)
1074 {
1075   unsigned int x;
1076   memcached_return rc;
1077
1078   {
1079     char *return_value;
1080     size_t return_value_length;
1081     uint16_t flags;
1082
1083     for (x= 0; x < GLOBAL_COUNT; x++)
1084     {
1085       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
1086                                   &return_value_length, &flags, &rc);
1087       /*
1088       assert(return_value);
1089       assert(rc == MEMCACHED_SUCCESS);
1090     */
1091       if (rc == MEMCACHED_SUCCESS && return_value)
1092         free(return_value);
1093     }
1094   }
1095
1096   return 0;
1097 }
1098
1099 uint8_t mget_read(memcached_st *memc)
1100 {
1101   memcached_return rc;
1102
1103   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1104   assert(rc == MEMCACHED_SUCCESS);
1105   /* Turn this into a help function */
1106   {
1107     char return_key[MEMCACHED_MAX_KEY];
1108     size_t return_key_length;
1109     char *return_value;
1110     size_t return_value_length;
1111     uint16_t flags;
1112
1113     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1114                                           &return_value_length, &flags, &rc)))
1115     {
1116       assert(return_value);
1117       assert(rc == MEMCACHED_SUCCESS);
1118       free(return_value);
1119     }
1120   }
1121
1122   return 0;
1123 }
1124
1125 uint8_t mget_read_result(memcached_st *memc)
1126 {
1127   memcached_return rc;
1128
1129   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1130   assert(rc == MEMCACHED_SUCCESS);
1131   /* Turn this into a help function */
1132   {
1133     memcached_result_st results_obj;
1134     memcached_result_st *results;
1135
1136     results= memcached_result_create(memc, &results_obj);
1137
1138     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1139     {
1140       assert(results);
1141       assert(rc == MEMCACHED_SUCCESS);
1142     }
1143
1144     memcached_result_free(&results_obj);
1145   }
1146
1147   return 0;
1148 }
1149
1150 uint8_t free_data(memcached_st *memc)
1151 {
1152   pairs_free(global_pairs);
1153
1154   return 0;
1155 }
1156
1157 uint8_t add_host_test1(memcached_st *memc)
1158 {
1159   unsigned int x;
1160   memcached_return rc;
1161   char servername[]= "0.example.com";
1162   memcached_server_st *servers;
1163
1164   servers= memcached_server_list_append(NULL, servername, 400, &rc);
1165   assert(servers);
1166   assert(1 == memcached_server_list_count(servers));
1167
1168   for (x= 2; x < 20; x++)
1169   {
1170     char buffer[SMALL_STRING_LEN];
1171
1172     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1173     servers= memcached_server_list_append(servers, buffer, 401,
1174                                      &rc);
1175     assert(rc == MEMCACHED_SUCCESS);
1176     assert(x == memcached_server_list_count(servers));
1177   }
1178
1179   rc= memcached_server_push(memc, servers);
1180   assert(rc == MEMCACHED_SUCCESS);
1181   rc= memcached_server_push(memc, servers);
1182   assert(rc == MEMCACHED_SUCCESS);
1183
1184   memcached_server_list_free(servers);
1185
1186   return 0;
1187 }
1188
1189 memcached_return pre_nonblock(memcached_st *memc)
1190 {
1191   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1192
1193   return MEMCACHED_SUCCESS;
1194 }
1195
1196 memcached_return pre_md5(memcached_st *memc)
1197 {
1198   memcached_hash value= MEMCACHED_HASH_MD5;
1199   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1200
1201   return MEMCACHED_SUCCESS;
1202 }
1203
1204 memcached_return pre_crc(memcached_st *memc)
1205 {
1206   memcached_hash value= MEMCACHED_HASH_CRC;
1207   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1208
1209   return MEMCACHED_SUCCESS;
1210 }
1211
1212 memcached_return pre_hash_fnv1_64(memcached_st *memc)
1213 {
1214   memcached_hash value= MEMCACHED_HASH_FNV1_64;
1215   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1216
1217   return MEMCACHED_SUCCESS;
1218 }
1219
1220 memcached_return pre_hash_fnv1a_64(memcached_st *memc)
1221 {
1222   memcached_hash value= MEMCACHED_HASH_FNV1A_64;
1223   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1224
1225   return MEMCACHED_SUCCESS;
1226 }
1227
1228 memcached_return pre_hash_fnv1_32(memcached_st *memc)
1229 {
1230   memcached_hash value= MEMCACHED_HASH_FNV1_32;
1231   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1232
1233   return MEMCACHED_SUCCESS;
1234 }
1235
1236 memcached_return pre_hash_fnv1a_32(memcached_st *memc)
1237 {
1238   memcached_hash value= MEMCACHED_HASH_FNV1A_32;
1239   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1240
1241   return MEMCACHED_SUCCESS;
1242 }
1243
1244 memcached_return pre_hash_ketama(memcached_st *memc)
1245 {
1246   memcached_hash value= MEMCACHED_HASH_KETAMA;
1247   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1248
1249   return MEMCACHED_SUCCESS;
1250 }
1251
1252 memcached_return pre_unix_socket(memcached_st *memc)
1253 {
1254   memcached_return rc;
1255   struct stat buf;
1256
1257   memcached_server_list_free(memc->hosts);
1258   memc->hosts= NULL;
1259   memc->number_of_hosts= 0;
1260
1261   if (stat("/tmp/memcached.socket", &buf))
1262     return MEMCACHED_FAILURE;
1263
1264   rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");
1265
1266   return rc;
1267 }
1268
1269 memcached_return pre_nodelay(memcached_st *memc)
1270 {
1271   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1272   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
1273
1274   return MEMCACHED_SUCCESS;
1275 }
1276
1277
1278 /* Clean the server before beginning testing */
1279 test_st tests[] ={
1280   {"flush", 0, flush_test },
1281   {"init", 0, init_test },
1282   {"allocation", 0, allocation_test },
1283   {"clone_test", 0, clone_test },
1284   {"error", 0, error_test },
1285   {"set", 0, set_test },
1286   {"set2", 0, set_test2 },
1287   {"set3", 0, set_test3 },
1288   {"add", 0, add_test },
1289   {"replace", 0, replace_test },
1290   {"delete", 1, delete_test },
1291   {"get", 1, get_test },
1292   {"get2", 0, get_test2 },
1293   {"get3", 0, get_test3 },
1294   {"get4", 0, get_test4 },
1295   {"stats_servername", 0, stats_servername_test },
1296   {"increment", 0, increment_test },
1297   {"decrement", 0, decrement_test },
1298   {"quit", 0, quit_test },
1299   {"mget", 1, mget_test },
1300   {"mget_result", 1, mget_result_test },
1301   {"mget_result_alloc", 1, mget_result_alloc_test },
1302   {"get_stats", 0, get_stats },
1303   {"add_host_test", 0, add_host_test },
1304   {"get_stats_keys", 0, get_stats_keys },
1305   {"behavior_test", 0, get_stats_keys },
1306   {0, 0, 0}
1307 };
1308
1309 test_st string_tests[] ={
1310   {"string static with null", 0, string_static_null },
1311   {"string alloc with null", 0, string_alloc_null },
1312   {"string alloc with 1K", 0, string_alloc_with_size },
1313   {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
1314   {"string append", 0, string_alloc_append },
1315   {"string append failure (too big)", 0, string_alloc_append_toobig },
1316   {0, 0, 0}
1317 };
1318
1319 test_st result_tests[] ={
1320   {"result static", 0, result_static},
1321   {"result alloc", 0, result_alloc},
1322   {0, 0, 0}
1323 };
1324
1325 test_st user_tests[] ={
1326   {"user_supplied_bug1", 0, user_supplied_bug1 },
1327   {"user_supplied_bug2", 0, user_supplied_bug2 },
1328   {"user_supplied_bug3", 0, user_supplied_bug3 },
1329   {"user_supplied_bug4", 0, user_supplied_bug4 },
1330   {0, 0, 0}
1331 };
1332
1333 test_st generate_tests[] ={
1334   {"generate_data", 0, generate_data },
1335   {"get_read", 0, get_read },
1336   {"mget_read", 0, mget_read },
1337   {"mget_read_result", 0, mget_read_result },
1338   {0, 0, 0}
1339 };
1340
1341
1342 collection_st collection[] ={
1343   {"block", 0, 0, tests},
1344   {"nonblock", pre_nonblock, 0, tests},
1345   {"nodelay", pre_nodelay, 0, tests},
1346   {"md5", pre_md5, 0, tests},
1347   {"crc", pre_crc, 0, tests},
1348   {"fnv1_64", pre_hash_fnv1_64, 0, tests},
1349   {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
1350   {"fnv1_32", pre_hash_fnv1_32, 0, tests},
1351   {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
1352   {"ketama", pre_hash_ketama, 0, tests},
1353   {"unix_socket", pre_unix_socket, 0, tests},
1354   {"unix_socket_nodelay", pre_nodelay, 0, tests},
1355   {"string", 0, 0, string_tests},
1356   {"result", 0, 0, result_tests},
1357   {"user", 0, 0, user_tests},
1358   {"generate", 0, 0, generate_tests},
1359   {0, 0, 0, 0}
1360 };
1361
1362 collection_st *gets_collections(void)
1363 {
1364   return collection;
1365 }