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(void)
  11 {
  12   memcached_st memc;
  13
  14   (void)memcached_init(&memc);
  15   memcached_deinit(&memc);
  16 }
  17
  18 void allocation_test(void)
  19 {
  20   memcached_st *memc;
  21   memc= memcached_init(NULL);
  22   assert(memc);
  23   memcached_deinit(memc);
  24 }
  25
  26 void connection_test(void)
  27 {
  28   memcached_return rc;
  29   memcached_st *memc;
  30   memc= memcached_init(NULL);
  31   rc= memcached_server_add(memc, "localhost", 0);
  32   assert(rc == MEMCACHED_SUCCESS);
  33   assert(memc);
  34   memcached_deinit(memc);
  35 }
  36
  37 void set_test(void)
  38 {
  39   memcached_st *memc;
  40   memcached_return rc;
  41   char *key= "foo";
  42   char *value= "when we sanitize";
  43
  44   memc= memcached_init(NULL);
  45   assert(memc);
  46   rc= memcached_set(memc, key, strlen(key),
  47                     value, strlen(value),
  48                     (time_t)0, (uint16_t)0);
  49   assert(rc == MEMCACHED_SUCCESS);
  50
  51   memcached_deinit(memc);
  52 }
  53
  54 void add_test(void)
  55 {
  56   memcached_st *memc;
  57   memcached_return rc;
  58   char *key= "foo";
  59   char *value= "when we sanitize";
  60
  61   memc= memcached_init(NULL);
  62   assert(memc);
  63   rc= memcached_add(memc, key, strlen(key),
  64                     value, strlen(value),
  65                     (time_t)0, (uint16_t)0);
  66   assert(rc == MEMCACHED_NOTSTORED);
  67
  68   memcached_deinit(memc);
  69 }
  70
  71 void replace_test(void)
  72 {
  73   memcached_st *memc;
  74   memcached_return rc;
  75   char *key= "foo";
  76   char *value= "when we sanitize";
  77
  78   memc= memcached_init(NULL);
  79   assert(memc);
  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   memcached_deinit(memc);
  86 }
  87
  88 void delete_test(void)
  89 {
  90   memcached_st *memc;
  91   memcached_return rc;
  92   char *key= "foo";
  93   char *value= "when we sanitize";
  94
  95   memc= memcached_init(NULL);
  96   assert(memc);
  97   rc= memcached_set(memc, key, strlen(key),
  98                     value, strlen(value),
  99                     (time_t)0, (uint16_t)0);
 100   assert(rc == MEMCACHED_SUCCESS);
 101
 102   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 103   assert(rc == MEMCACHED_SUCCESS);
 104
 105   memcached_deinit(memc);
 106 }
 107
 108 void flush_test(void)
 109 {
 110   memcached_st *memc;
 111   memcached_return rc;
 112
 113   memc= memcached_init(NULL);
 114   assert(memc);
 115   rc= memcached_flush(memc, 0);
 116   assert(rc == MEMCACHED_SUCCESS);
 117
 118   memcached_deinit(memc);
 119 }
 120
 121 void get_test(void)
 122 {
 123   memcached_st *memc;
 124   memcached_return rc;
 125   char *key= "foo";
 126   char *string;
 127   size_t string_length;
 128   uint16_t flags;
 129
 130   memc= memcached_init(NULL);
 131   assert(memc);
 132
 133   string= memcached_get(memc, key, strlen(key),
 134                         &string_length, &flags, &rc);
 135
 136   printf("RC %u\n", rc);
 137   assert(rc == MEMCACHED_NOTFOUND);
 138   assert(string_length ==  0);
 139   assert(!string);
 140
 141   memcached_deinit(memc);
 142 }
 143
 144 void get_test2(void)
 145 {
 146   memcached_st *memc;
 147   memcached_return rc;
 148   char *key= "foo";
 149   char *value= "when we sanitize";
 150   char *string;
 151   size_t string_length;
 152   uint16_t flags;
 153
 154   memc= memcached_init(NULL);
 155   assert(memc);
 156   rc= memcached_set(memc, key, strlen(key),
 157                     value, strlen(value),
 158                     (time_t)0, (uint16_t)0);
 159   assert(rc == MEMCACHED_SUCCESS);
 160
 161   string= memcached_get(memc, key, strlen(key),
 162                         &string_length, &flags, &rc);
 163
 164   assert(string_length == strlen(value));
 165   assert(!memcmp(string, value, string_length));
 166
 167   free(string);
 168
 169   memcached_deinit(memc);
 170 }
 171
 172 void stats_hostname_test(void)
 173 {
 174   memcached_return rc;
 175   memcached_stat_st stat;
 176   rc= memcached_stat_hostname(&stat, NULL,
 177                               "localhost",
 178                               MEMCACHED_DEFAULT_PORT);
 179 }
 180
 181 void increment_test(void)
 182 {
 183   memcached_st *memc;
 184   unsigned int new_number;
 185   memcached_return rc;
 186   char *key= "number";
 187   char *value= "0";
 188
 189   memc= memcached_init(NULL);
 190   assert(memc);
 191   rc= memcached_set(memc, key, strlen(key),
 192                     value, strlen(value),
 193                     (time_t)0, (uint16_t)0);
 194   assert(rc == MEMCACHED_SUCCESS);
 195
 196   rc= memcached_increment(memc, key, strlen(key),
 197                           1, &new_number);
 198   assert(rc == MEMCACHED_SUCCESS);
 199   assert(new_number == 1);
 200
 201   rc= memcached_increment(memc, key, strlen(key),
 202                           1, &new_number);
 203   assert(rc == MEMCACHED_SUCCESS);
 204   assert(new_number == 2);
 205
 206   memcached_deinit(memc);
 207 }
 208
 209 void decrement_test(void)
 210 {
 211   memcached_st *memc;
 212   unsigned int new_number;
 213   memcached_return rc;
 214   char *key= "number";
 215   char *value= "3";
 216
 217   memc= memcached_init(NULL);
 218   assert(memc);
 219   rc= memcached_set(memc, key, strlen(key),
 220                     value, strlen(value),
 221                     (time_t)0, (uint16_t)0);
 222   assert(rc == MEMCACHED_SUCCESS);
 223
 224   rc= memcached_decrement(memc, key, strlen(key),
 225                           1, &new_number);
 226   assert(rc == MEMCACHED_SUCCESS);
 227   assert(new_number == 2);
 228
 229   rc= memcached_decrement(memc, key, strlen(key),
 230                           1, &new_number);
 231   assert(rc == MEMCACHED_SUCCESS);
 232   assert(new_number == 1);
 233
 234   memcached_deinit(memc);
 235 }
 236
 237 int main(void)
 238 {
 239   /* Clean the server before beginning testing */
 240   flush_test();
 241
 242   init_test();
 243   allocation_test();
 244   connection_test();
 245   set_test();
 246   add_test();
 247   replace_test();
 248   flush_test();
 249   delete_test();
 250   flush_test();
 251   get_test();
 252   get_test2();
 253   stats_hostname_test();
 254
 255   increment_test();
 256   decrement_test();
 257
 258   /* Clean up whatever we might have left */
 259   flush_test();
 260   return 0;
 261 }