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