git.m6w6.name Git - awesomized/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   char *foo;
  31   memcached_return rc;
  32   char *key= "foo";
  33   char *value= "when we sanitize";
  34
  35   memc= memcached_init(NULL);
  36   assert(memc);
  37   rc= memcached_set(memc, key, strlen(key),
  38                     value, strlen(value),
  39                     (time_t)0, (uint16_t)0);
  40   assert(rc == MEMCACHED_SUCCESS);
  41   assert(foo);
  42
  43   memcached_deinit(memc);
  44 }
  45
  46 void add_test(void)
  47 {
  48   memcached_st *memc;
  49   char *foo;
  50   memcached_return rc;
  51   char *key= "foo";
  52   char *value= "when we sanitize";
  53
  54   memc= memcached_init(NULL);
  55   assert(memc);
  56   rc= memcached_add(memc, key, strlen(key),
  57                     value, strlen(value),
  58                     (time_t)0, (uint16_t)0);
  59   assert(rc == MEMCACHED_NOTSTORED);
  60   assert(foo);
  61
  62   memcached_deinit(memc);
  63 }
  64
  65 void replace_test(void)
  66 {
  67   memcached_st *memc;
  68   char *foo;
  69   memcached_return rc;
  70   char *key= "foo";
  71   char *value= "when we sanitize";
  72
  73   memc= memcached_init(NULL);
  74   assert(memc);
  75   rc= memcached_replace(memc, key, strlen(key),
  76                     value, strlen(value),
  77                     (time_t)0, (uint16_t)0);
  78   assert(rc == MEMCACHED_SUCCESS);
  79   assert(foo);
  80
  81   memcached_deinit(memc);
  82 }
  83
  84 void delete_test(void)
  85 {
  86   memcached_st *memc;
  87   char *foo;
  88   memcached_return rc;
  89   char *key= "foo";
  90   char *value= "when we sanitize";
  91
  92   memc= memcached_init(NULL);
  93   assert(memc);
  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   assert(foo);
  99
 100   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 101   assert(rc == MEMCACHED_SUCCESS);
 102   assert(foo);
 103
 104   memcached_deinit(memc);
 105 }
 106
 107 void flush_test(void)
 108 {
 109   memcached_st *memc;
 110   memcached_return rc;
 111
 112   memc= memcached_init(NULL);
 113   assert(memc);
 114   rc= memcached_flush(memc, 0);
 115   assert(rc == MEMCACHED_SUCCESS);
 116
 117   memcached_deinit(memc);
 118 }
 119
 120 void get_test(void)
 121 {
 122   memcached_st *memc;
 123   memcached_return rc;
 124   char *key= "foo";
 125   char *string;
 126   size_t string_length;
 127   uint16_t flags;
 128
 129   memc= memcached_init(NULL);
 130   assert(memc);
 131
 132   string= memcached_get(memc, key, strlen(key),
 133                         &string_length, &flags, &rc);
 134
 135   assert(string_length ==  0);
 136   assert(!string);
 137
 138   memcached_deinit(memc);
 139 }
 140
 141 void get_test2(void)
 142 {
 143   memcached_st *memc;
 144   char *foo;
 145   memcached_return rc;
 146   char *key= "foo";
 147   char *value= "when we sanitize";
 148   char *string;
 149   size_t string_length;
 150   uint16_t flags;
 151
 152   memc= memcached_init(NULL);
 153   assert(memc);
 154   rc= memcached_set(memc, key, strlen(key),
 155                     value, strlen(value),
 156                     (time_t)0, (uint16_t)0);
 157   assert(rc == MEMCACHED_SUCCESS);
 158
 159   string= memcached_get(memc, key, strlen(key),
 160                         &string_length, &flags, &rc);
 161
 162   assert(string_length == strlen(value));
 163   assert(!memcmp(string, value, string_length));
 164
 165   free(string);
 166
 167   memcached_deinit(memc);
 168 }
 169
 170 void stats_hostname_test(void)
 171 {
 172   memcached_return rc;
 173   memcached_stat_st stat;
 174   rc= memcached_stat_hostname(&stat, NULL,
 175                               "localhost",
 176                               MEMCACHED_DEFAULT_PORT);
 177 }
 178
 179 int main(void)
 180 {
 181   /* Clean the server before beginning testing */
 182   flush_test();
 183
 184   init_test();
 185   allocation_test();
 186   set_test();
 187   add_test();
 188   replace_test();
 189   flush_test();
 190   delete_test();
 191   flush_test();
 192   get_test();
 193   get_test2();
 194   stats_hostname_test();
 195
 196   /* Clean up whatever we might have left */
 197   flush_test();
 198   return 0;
 199 }