git.m6w6.name Git - awesomized/libmemcached/blob - tests/test.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
  10 void init_test(memcached_st *not_used)
  11 {
  12   memcached_st memc;
  13
  14   (void)memcached_create(&memc);
  15   memcached_free(&memc);
  16 }
  17
  18 void allocation_test(memcached_st *not_used)
  19 {
  20   memcached_st *memc;
  21   memc= memcached_create(NULL);
  22   assert(memc);
  23   memcached_free(memc);
  24 }
  25
  26 void connection_test(memcached_st *memc)
  27 {
  28   memcached_return rc;
  29
  30   rc= memcached_server_add(memc, "localhost", 0);
  31   assert(rc == MEMCACHED_SUCCESS);
  32 }
  33
  34 void error_test(memcached_st *memc)
  35 {
  36   memcached_return rc;
  37
  38   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
  39   {
  40     printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
  41   }
  42 }
  43
  44 void set_test(memcached_st *memc)
  45 {
  46   memcached_return rc;
  47   char *key= "foo";
  48   char *value= "when we sanitize";
  49
  50   rc= memcached_set(memc, key, strlen(key),
  51                     value, strlen(value),
  52                     (time_t)0, (uint16_t)0);
  53   assert(rc == MEMCACHED_SUCCESS);
  54 }
  55
  56 void add_test(memcached_st *memc)
  57 {
  58   memcached_return rc;
  59   char *key= "foo";
  60   char *value= "when we sanitize";
  61
  62   rc= memcached_add(memc, key, strlen(key),
  63                     value, strlen(value),
  64                     (time_t)0, (uint16_t)0);
  65   assert(rc == MEMCACHED_NOTSTORED);
  66 }
  67
  68 void replace_test(memcached_st *memc)
  69 {
  70   memcached_return rc;
  71   char *key= "foo";
  72   char *value= "when we sanitize";
  73
  74   rc= memcached_replace(memc, key, strlen(key),
  75                     value, strlen(value),
  76                     (time_t)0, (uint16_t)0);
  77   assert(rc == MEMCACHED_SUCCESS);
  78 }
  79
  80 void delete_test(memcached_st *memc)
  81 {
  82   memcached_return rc;
  83   char *key= "foo";
  84   char *value= "when we sanitize";
  85
  86   rc= memcached_set(memc, key, strlen(key),
  87                     value, strlen(value),
  88                     (time_t)0, (uint16_t)0);
  89   assert(rc == MEMCACHED_SUCCESS);
  90
  91   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
  92   assert(rc == MEMCACHED_SUCCESS);
  93 }
  94
  95 void flush_test(memcached_st *memc)
  96 {
  97   memcached_return rc;
  98
  99   rc= memcached_flush(memc, 0);
 100   assert(rc == MEMCACHED_SUCCESS);
 101 }
 102
 103 void get_test(memcached_st *memc)
 104 {
 105   memcached_return rc;
 106   char *key= "foo";
 107   char *string;
 108   size_t string_length;
 109   uint16_t flags;
 110
 111   string= memcached_get(memc, key, strlen(key),
 112                         &string_length, &flags, &rc);
 113
 114   assert(rc == MEMCACHED_NOTFOUND);
 115   assert(string_length ==  0);
 116   assert(!string);
 117 }
 118
 119 void get_test2(memcached_st *memc)
 120 {
 121   memcached_return rc;
 122   char *key= "foo";
 123   char *value= "when we sanitize";
 124   char *string;
 125   size_t string_length;
 126   uint16_t flags;
 127
 128   rc= memcached_set(memc, key, strlen(key),
 129                     value, strlen(value),
 130                     (time_t)0, (uint16_t)0);
 131   assert(rc == MEMCACHED_SUCCESS);
 132
 133   string= memcached_get(memc, key, strlen(key),
 134                         &string_length, &flags, &rc);
 135
 136   assert(string);
 137   assert(rc == MEMCACHED_SUCCESS);
 138   assert(string_length == strlen(value));
 139   assert(!memcmp(string, value, string_length));
 140
 141   free(string);
 142 }
 143
 144 void set_test2(memcached_st *memc)
 145 {
 146   memcached_return rc;
 147   char *key= "foo";
 148   char *value= "train in the brain";
 149   size_t value_length= strlen(value);
 150   unsigned int x;
 151
 152   for (x= 0; x < 10; x++)
 153   {
 154     rc= memcached_set(memc, key, strlen(key),
 155                       value, value_length,
 156                       (time_t)0, (uint16_t)0);
 157     assert(rc == MEMCACHED_SUCCESS);
 158   }
 159 }
 160
 161 void set_test3(memcached_st *memc)
 162 {
 163   memcached_return rc;
 164   char *key= "foo";
 165   char *value;
 166   size_t value_length= 8191;
 167   unsigned int x;
 168
 169   value = (char*)malloc(value_length);
 170   assert(value);
 171
 172   for (x= 0; x < value_length; x++)
 173     value[x] = (char) (x % 127);
 174
 175   for (x= 0; x < 1; x++)
 176   {
 177     rc= memcached_set(memc, key, strlen(key),
 178                       value, value_length,
 179                       (time_t)0, (uint16_t)0);
 180     assert(rc == MEMCACHED_SUCCESS);
 181   }
 182
 183   free(value);
 184 }
 185
 186 void get_test3(memcached_st *memc)
 187 {
 188   memcached_return rc;
 189   char *key= "foo";
 190   char *value;
 191   size_t value_length= 8191;
 192   char *string;
 193   size_t string_length;
 194   uint16_t flags;
 195   int x;
 196
 197   value = (char*)malloc(value_length);
 198   assert(value);
 199
 200   for (x= 0; x < value_length; x++)
 201     value[x] = (char) (x % 127);
 202
 203   rc= memcached_set(memc, key, strlen(key),
 204                     value, value_length,
 205                     (time_t)0, (uint16_t)0);
 206   assert(rc == MEMCACHED_SUCCESS);
 207
 208   string= memcached_get(memc, key, strlen(key),
 209                         &string_length, &flags, &rc);
 210
 211   assert(rc == MEMCACHED_SUCCESS);
 212   assert(string);
 213   assert(string_length == value_length);
 214   assert(!memcmp(string, value, string_length));
 215
 216   free(string);
 217   free(value);
 218 }
 219
 220 void get_test4(memcached_st *memc)
 221 {
 222   memcached_return rc;
 223   char *key= "foo";
 224   char *value;
 225   size_t value_length= 8191;
 226   char *string;
 227   size_t string_length;
 228   uint16_t flags;
 229   int x;
 230
 231   value = (char*)malloc(value_length);
 232   assert(value);
 233
 234   for (x= 0; x < value_length; x++)
 235     value[x] = (char) (x % 127);
 236
 237   rc= memcached_set(memc, key, strlen(key),
 238                     value, value_length,
 239                     (time_t)0, (uint16_t)0);
 240   assert(rc == MEMCACHED_SUCCESS);
 241
 242   for (x= 0; x < 10; x++)
 243   {
 244     string= memcached_get(memc, key, strlen(key),
 245                           &string_length, &flags, &rc);
 246
 247     assert(rc == MEMCACHED_SUCCESS);
 248     assert(string);
 249     assert(string_length == value_length);
 250     assert(!memcmp(string, value, string_length));
 251     free(string);
 252   }
 253
 254   free(value);
 255 }
 256
 257 void stats_servername_test(memcached_st *memc)
 258 {
 259   memcached_return rc;
 260   memcached_stat_st stat;
 261   rc= memcached_stat_servername(&stat, NULL,
 262                                  "localhost",
 263                                  MEMCACHED_DEFAULT_PORT);
 264 }
 265
 266 void increment_test(memcached_st *memc)
 267 {
 268   unsigned int new_number;
 269   memcached_return rc;
 270   char *key= "number";
 271   char *value= "0";
 272
 273   rc= memcached_set(memc, key, strlen(key),
 274                     value, strlen(value),
 275                     (time_t)0, (uint16_t)0);
 276   assert(rc == MEMCACHED_SUCCESS);
 277
 278   rc= memcached_increment(memc, key, strlen(key),
 279                           1, &new_number);
 280   assert(rc == MEMCACHED_SUCCESS);
 281   assert(new_number == 1);
 282
 283   rc= memcached_increment(memc, key, strlen(key),
 284                           1, &new_number);
 285   assert(rc == MEMCACHED_SUCCESS);
 286   assert(new_number == 2);
 287 }
 288
 289 void decrement_test(memcached_st *memc)
 290 {
 291   unsigned int new_number;
 292   memcached_return rc;
 293   char *key= "number";
 294   char *value= "3";
 295
 296   rc= memcached_set(memc, key, strlen(key),
 297                     value, strlen(value),
 298                     (time_t)0, (uint16_t)0);
 299   assert(rc == MEMCACHED_SUCCESS);
 300
 301   rc= memcached_decrement(memc, key, strlen(key),
 302                           1, &new_number);
 303   assert(rc == MEMCACHED_SUCCESS);
 304   assert(new_number == 2);
 305
 306   rc= memcached_decrement(memc, key, strlen(key),
 307                           1, &new_number);
 308   assert(rc == MEMCACHED_SUCCESS);
 309   assert(new_number == 1);
 310 }
 311
 312 void quit_test(memcached_st *memc)
 313 {
 314   memcached_return rc;
 315   char *key= "fudge";
 316   char *value= "sanford and sun";
 317
 318   rc= memcached_set(memc, key, strlen(key),
 319                     value, strlen(value),
 320                     (time_t)10, (uint16_t)3);
 321   assert(rc == MEMCACHED_SUCCESS);
 322   memcached_quit(memc);
 323
 324   rc= memcached_set(memc, key, strlen(key),
 325                     value, strlen(value),
 326                     (time_t)50, (uint16_t)9);
 327   assert(rc == MEMCACHED_SUCCESS);
 328 }
 329
 330 void mget_test(memcached_st *memc)
 331 {
 332   memcached_return rc;
 333   char *keys[]= {"fudge", "son", "food"};
 334   size_t key_length[]= {5, 3, 4};
 335   unsigned int x;
 336   uint16_t flags;
 337
 338   char return_key[MEMCACHED_MAX_KEY];
 339   size_t return_key_length;
 340   char *return_value;
 341   size_t return_value_length;
 342
 343   /* We need to empty the server before continueing test */
 344   rc= memcached_flush(memc, 0);
 345   assert(rc == MEMCACHED_SUCCESS);
 346
 347   rc= memcached_mget(memc, keys, key_length, 3);
 348   assert(rc == MEMCACHED_SUCCESS);
 349
 350   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 351                       &return_value_length, &flags, &rc)) != NULL)
 352   {
 353     assert(return_value);
 354   }
 355   assert(!return_value);
 356   assert(return_value_length == 0);
 357   assert(rc == MEMCACHED_NOTFOUND);
 358
 359   for (x= 0; x < 3; x++)
 360   {
 361     rc= memcached_set(memc, keys[x], key_length[x],
 362                       keys[x], key_length[x],
 363                       (time_t)50, (uint16_t)9);
 364     assert(rc == MEMCACHED_SUCCESS);
 365   }
 366
 367   rc= memcached_mget(memc, keys, key_length, 3);
 368   assert(rc == MEMCACHED_SUCCESS);
 369
 370   x= 0;
 371   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 372                                         &return_value_length, &flags, &rc)))
 373   {
 374     assert(return_value);
 375     assert(rc == MEMCACHED_SUCCESS);
 376     assert(return_key_length == return_value_length);
 377     assert(!memcmp(return_value, return_key, return_value_length));
 378     free(return_value);
 379     x++;
 380   }
 381 }
 382
 383 void get_stats_keys(memcached_st *memc)
 384 {
 385  char **list;
 386  char **ptr;
 387  memcached_stat_st stat;
 388  memcached_return rc;
 389
 390  list= memcached_stat_get_keys(memc, &stat, &rc);
 391  assert(rc == MEMCACHED_SUCCESS);
 392  for (ptr= list; *ptr; ptr++)
 393    printf("Found key %s\n", *ptr);
 394
 395  free(list);
 396 }
 397
 398 void get_stats(memcached_st *memc)
 399 {
 400  unsigned int x;
 401  char **list;
 402  char **ptr;
 403  memcached_return rc;
 404  memcached_stat_st *stat;
 405
 406  stat= memcached_stat(memc, NULL, &rc);
 407  assert(rc == MEMCACHED_SUCCESS);
 408
 409  assert(rc == MEMCACHED_SUCCESS);
 410  assert(stat);
 411
 412  for (x= 0; x < memcached_server_count(memc); x++)
 413  {
 414    list= memcached_stat_get_keys(memc, &stat[x], &rc);
 415    assert(rc == MEMCACHED_SUCCESS);
 416    for (ptr= list; *ptr; ptr++)
 417      printf("Found key %s\n", *ptr);
 418
 419    free(list);
 420  }
 421
 422  free(stat);
 423 }
 424
 425 void add_host_test(memcached_st *memc)
 426 {
 427   unsigned int x;
 428   memcached_server_st *servers;
 429   memcached_return rc;
 430   char servername[]= "0.example.com";
 431
 432   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 433   assert(servers);
 434   assert(1 == memcached_server_list_count(servers));
 435
 436   for (x= 2; x < 20; x++)
 437   {
 438     char buffer[SMALL_STRING_LEN];
 439
 440     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 441     servers= memcached_server_list_append(servers, buffer, 401,
 442                                      &rc);
 443     assert(rc == MEMCACHED_SUCCESS);
 444     assert(x == memcached_server_list_count(servers));
 445   }
 446
 447   rc= memcached_server_push(memc, servers);
 448   assert(rc == MEMCACHED_SUCCESS);
 449   rc= memcached_server_push(memc, servers);
 450   assert(rc == MEMCACHED_SUCCESS);
 451
 452   memcached_server_list_free(servers);
 453 }
 454
 455 /* We don't test the behavior itself, we test the switches */
 456 void behavior_test(memcached_st *memc)
 457 {
 458   unsigned long long value;
 459   unsigned int set= 1;
 460
 461   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 462   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 463   assert(value == 1);
 464
 465   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 466   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 467   assert(value == 1);
 468
 469   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, &set);
 470   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_MD5_HASHING);
 471   assert(value == 1);
 472
 473   set= 0;
 474
 475   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 476   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 477   assert(value == 0);
 478
 479   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 480   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 481   assert(value == 0);
 482
 483   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, &set);
 484   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_MD5_HASHING);
 485   assert(value == 0);
 486 }
 487
 488 void add_host_test1(memcached_st *memc)
 489 {
 490   unsigned int x;
 491   memcached_return rc;
 492   char servername[]= "0.example.com";
 493   memcached_server_st *servers;
 494
 495   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 496   assert(servers);
 497   assert(1 == memcached_server_list_count(servers));
 498
 499   for (x= 2; x < 20; x++)
 500   {
 501     char buffer[SMALL_STRING_LEN];
 502
 503     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 504     servers= memcached_server_list_append(servers, buffer, 401,
 505                                      &rc);
 506     assert(rc == MEMCACHED_SUCCESS);
 507     assert(x == memcached_server_list_count(servers));
 508   }
 509
 510   rc= memcached_server_push(memc, servers);
 511   assert(rc == MEMCACHED_SUCCESS);
 512   rc= memcached_server_push(memc, servers);
 513   assert(rc == MEMCACHED_SUCCESS);
 514
 515   memcached_server_list_free(servers);
 516 }
 517
 518 typedef struct test_st test_st;
 519
 520 struct test_st {
 521   char *function_name;
 522   unsigned int requires_flush;
 523   void (*function)(memcached_st *memc);
 524 };
 525
 526 int main(int argc, char *argv[])
 527 {
 528   unsigned int x;
 529   char *server_list;
 530   memcached_server_st *servers;
 531
 532   if (!(server_list= getenv("MEMCACHED_SERVERS")))
 533     server_list= "localhost";
 534
 535   printf("servers %s\n", server_list);
 536
 537   servers= memcached_servers_parse(server_list);
 538   assert(servers);
 539
 540   /* Clean the server before beginning testing */
 541   test_st tests[] ={
 542     {"flush", 0, flush_test },
 543     {"init", 0, init_test },
 544     {"allocation", 0, allocation_test },
 545     {"error", 0, error_test },
 546     {"set", 0, set_test },
 547     {"set2", 0, set_test2 },
 548     {"set3", 0, set_test3 },
 549     {"add", 0, add_test },
 550     {"replace", 0, replace_test },
 551     {"delete", 1, delete_test },
 552     {"get", 0, get_test },
 553     {"get2", 0, get_test2 },
 554     {"get3", 0, get_test3 },
 555     {"get4", 0, get_test4 },
 556     {"stats_servername", 0, stats_servername_test },
 557     {"increment", 0, increment_test },
 558     {"decrement", 0, decrement_test },
 559     {"quit", 0, quit_test },
 560     {"mget", 0, mget_test },
 561     {"get_stats", 0, get_stats },
 562     {"add_host_test", 0, add_host_test },
 563     {"get_stats_keys", 0, get_stats_keys },
 564     {"behavior_test", 0, get_stats_keys },
 565     {0, 0, 0}
 566   };
 567
 568   fprintf(stderr, "\nBlock tests\n\n");
 569   for (x= 0; tests[x].function_name; x++)
 570   {
 571     memcached_st *memc;
 572     memcached_return rc;
 573     memc= memcached_create(NULL);
 574     assert(memc);
 575
 576     rc= memcached_server_push(memc, servers);
 577     assert(rc == MEMCACHED_SUCCESS);
 578
 579     fprintf(stderr, "Testing %s", tests[x].function_name);
 580     tests[x].function(memc);
 581     fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
 582     assert(memc);
 583     memcached_free(memc);
 584   }
 585
 586   fprintf(stderr, "\nNonblock tests\n\n");
 587   for (x= 0; tests[x].function_name; x++)
 588   {
 589     memcached_st *memc;
 590     memcached_return rc;
 591     memc= memcached_create(NULL);
 592     assert(memc);
 593
 594     rc= memcached_server_push(memc, servers);
 595     assert(rc == MEMCACHED_SUCCESS);
 596
 597     fprintf(stderr, "Testing %s", tests[x].function_name);
 598     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
 599     tests[x].function(memc);
 600     fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
 601     assert(memc);
 602     memcached_free(memc);
 603   }
 604
 605   fprintf(stderr, "\nTCP Nodelay tests\n\n");
 606   for (x= 0; tests[x].function_name; x++)
 607   {
 608     memcached_st *memc;
 609     memcached_return rc;
 610     memc= memcached_create(NULL);
 611     assert(memc);
 612
 613     rc= memcached_server_push(memc, servers);
 614     assert(rc == MEMCACHED_SUCCESS);
 615
 616     fprintf(stderr, "Testing %s", tests[x].function_name);
 617     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
 618     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
 619     tests[x].function(memc);
 620     fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
 621     assert(memc);
 622     memcached_free(memc);
 623   }
 624
 625   fprintf(stderr, "\nMD5 Hashing\n\n");
 626   for (x= 0; tests[x].function_name; x++)
 627   {
 628     memcached_st *memc;
 629     memcached_return rc;
 630     memc= memcached_create(NULL);
 631     assert(memc);
 632
 633     rc= memcached_server_push(memc, servers);
 634     assert(rc == MEMCACHED_SUCCESS);
 635
 636     fprintf(stderr, "Testing %s", tests[x].function_name);
 637     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, NULL);
 638     tests[x].function(memc);
 639     fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
 640     assert(memc);
 641     memcached_free(memc);
 642   }
 643
 644   /* Clean up whatever we might have left */
 645   {
 646     memcached_st *memc;
 647     memc= memcached_create(NULL);
 648     assert(memc);
 649     flush_test(memc);
 650     memcached_free(memc);
 651   }
 652   return 0;
 653 }