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