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