git.m6w6.name Git - m6w6/libmemcached/blob - tests/test.c

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