uniconf/t/uniinigen.t.cc

   1 #include "uniinigen.h"
   2 #include "wvfile.h"
   3 #include "wvfileutils.h"
   4 #include "uniconfroot.h"
   5 #ifdef _WIN32
   6 #include <sys/stat.h>
   7 #endif
   8 #include "uniwatch.h"
   9 #include "wvsystem.h"
  10 #include "wvtest.h"
  11 #include "uniconfgen-sanitytest.h"
  12
  13 #ifdef _WIN32
  14 static inline int mkdir(const char *x, int y) { return mkdir(x); }
  15 #endif
  16
  17 // Returns the filename where the content was written.  This file must be
  18 // deleted when no longer needed.  Returns WvString::null if unable to create
  19 // the file.
  20 WvString inigen(WvStringParm content)
  21 {
  22     WvString ininame = wvtmpfilename("inigen_test.ini");
  23     WvFile file;
  24     WVPASS(file.open(ininame, O_CREAT|O_RDWR));
  25     file.write(content);
  26     WVPASS(file.isok());
  27
  28     return ininame;
  29 }
  30
  31 static int childcount(UniConf cfg)
  32 {
  33     int count = 0;
  34     UniConf::Iter i(cfg);
  35     for (i.rewind(); i.next(); )
  36         count++;
  37     return count;
  38 }
  39
  40
  41 WVTEST_MAIN("UniIniGen Sanity Test")
  42 {
  43     WvString inifile("/tmp/inigen-test-%s.ini", getpid());
  44     UniIniGen *gen = new UniIniGen(inifile);
  45     UniConfGenSanityTester::sanity_test(gen, WvString("ini:%s", inifile));
  46     WVRELEASE(gen);
  47     unlink(inifile);
  48 }
  49
  50 WVTEST_MAIN("commit-without-refresh")
  51 {
  52
  53     UniConfRoot cfg("ini:/dev/does-not-exist");
  54     cfg.commit();
  55     cfg.refresh();
  56     cfg.commit();
  57     WVFAIL(cfg.haschildren());
  58 }
  59
  60 #ifndef _WIN32
  61 WVTEST_MAIN("ini file permissions")
  62 {
  63     system("rm -f perm.ini");
  64     system("touch perm.ini");
  65     UniConfRoot cfg("ini:perm.ini");
  66     cfg["foo"].setme("bar");
  67     mode_t oldmask = umask(02);
  68     cfg.commit();
  69     umask(oldmask);
  70
  71     struct stat statbuf;
  72     WVPASS(stat("perm.ini", &statbuf) == 0);
  73     WVPASSEQ(statbuf.st_mode, 0100664); //file and permissions 0664
  74
  75     system("rm -f perm.ini");
  76 }
  77 #endif
  78
  79 WVTEST_MAIN("parsing1")
  80 {
  81     WvString ininame = inigen("[S1]\n"
  82            "a = b\n"
  83            "[{S2}]  \n"
  84            "c=d  \n"
  85            "[{S\n3}]\n"
  86            "e=f\n");
  87     UniConfRoot cfg(WvString("ini:%s", ininame));
  88
  89     WVPASSEQ(cfg["S1/a"].getme(), "b");
  90     WVPASSEQ(cfg["S2/c"].getme(), "d");
  91     WVPASSEQ(cfg["S\n3/e"].getme(), "f");
  92     WVPASSEQ(childcount(cfg), 3);
  93
  94     ::unlink(ininame);
  95 }
  96
  97
  98 WVTEST_MAIN("parsing2")
  99 {
 100     WvString ininame = inigen("[x]\n"
 101            "[]\n"
 102            "  a    =    b c   \n"
 103            "  { a\n  b}  {c  }   = {  a\n  b2}  {c  }\n"
 104            "apenwarr = {OBFU}scation!");
 105     UniConfRoot cfg(WvString("ini:%s", ininame));
 106
 107     WVPASSEQ(cfg["a"].getme(), "b c");
 108     WVPASSEQ(cfg[" a\n  b}  {c  "].getme(), "  a\n  b2}  {c  ");
 109     WVPASSEQ(cfg["apenwarr"].getme(), "{OBFU}scation!");
 110
 111     ::unlink(ininame);
 112 }
 113
 114
 115 WVTEST_MAIN("parsing3")
 116 {
 117     WvString ininame = inigen("/ = foo\n");
 118     UniConfRoot cfg(WvString("ini:%s", ininame));
 119     WVPASSEQ(cfg.getme(), "foo");
 120     WVFAIL(cfg.haschildren());
 121
 122     ::unlink(ininame);
 123 }
 124
 125
 126 WVTEST_MAIN("parsing4")
 127 {
 128     // first line should be dropped to try to recover, since the entire
 129     // file is invalid tcl-encoding.
 130     WvString ininame = inigen("{ broken\n/ = boo\n");
 131     UniConfRoot cfg(WvString("ini:%s", ininame));
 132     WVPASSEQ(cfg.getme(), "boo");
 133     WVFAIL(cfg.haschildren());
 134 }
 135
 136
 137 WVTEST_MAIN("Setting and getting (bug 6090)")
 138 {
 139     WvString ininame = inigen("");
 140     UniConfRoot cfg(WvString("ini:%s", ininame));
 141
 142     cfg["mrwise"].setme("{{bork!");
 143     cfg.commit();
 144     WVPASSEQ(cfg["mrwise"].getme(), "{{bork!");
 145
 146     UniConfRoot cfg2(WvString("ini:%s", ininame));
 147     WVPASSEQ(cfg2["mrwise"].getme(), "{{bork!");
 148
 149     ::unlink(ininame);
 150 }
 151
 152 // This is probably covered by sanity tests now.  OTOH, more tests is more
 153 // better.
 154 WVTEST_MAIN("Trailing slashes")
 155 {
 156     UniConfRoot cfg("ini:tmp.ini");
 157
 158     cfg["sfllaw"].setme("law");
 159     WVPASSEQ(cfg["sfllaw"].getme(), "law");
 160     WVPASSEQ(cfg["sfllaw/"].getme(), "");
 161
 162     cfg["sfllaw/"].setme("LAW");
 163     WVPASSEQ(cfg["sfllaw"].getme(), "law");
 164     WVPASSEQ(cfg["sfllaw/"].getme(), "");
 165 }
 166
 167 static void count_cb(int *i, const UniConf &cfg, const UniConfKey &key)
 168 {
 169     (*i)++;
 170 }
 171
 172
 173 WVTEST_MAIN("ini callbacks")
 174 {
 175     int i = 0;
 176     WvString ininame = inigen("a/b/c/1 = 11\n"
 177                               "a/b/c/2 = 22\n");
 178     UniConfRoot cfg(WvString("ini:%s", ininame));
 179     UniWatch w(cfg, wv::bind(&count_cb, &i, _1, _2), true);
 180
 181     WVPASSEQ(i, 0);
 182     cfg.refresh();
 183     WVPASSEQ(i, 0);
 184
 185     {
 186         WvFile f(ininame, O_WRONLY|O_TRUNC);
 187         f.print("a/b/c/1 = 111\n"
 188                 "a/b/c/2 = 222\n");
 189         cfg.refresh();
 190         WVPASSEQ(i, 2);
 191
 192         f.print("a/b/c/3 = 333\n");
 193         cfg.refresh();
 194         WVPASSEQ(i, 3);
 195
 196         f.print("\n");
 197         cfg.refresh();
 198         WVPASSEQ(i, 3);
 199     }
 200
 201     cfg.xset("x", "y");
 202     WVPASSEQ(i, 4);
 203     cfg.commit();
 204     WVPASSEQ(i, 4);
 205     cfg.refresh();
 206     WVPASSEQ(i, 4);
 207
 208     ::unlink(ininame);
 209 }
 210
 211
 212 static void inicmp(WvStringParm key, WvStringParm val, WvStringParm content)
 213 {
 214     WvString ininame = inigen("");
 215     UniConfRoot cfg(WvString("ini:%s", ininame));
 216     cfg[key].setme(val);
 217     cfg.commit();
 218
 219     WvFile f(ininame, O_RDONLY);
 220     WvDynBuf buf;
 221     f.read(buf, 128*1024);
 222     WVPASSEQ(content, buf.getstr());
 223     ::unlink(ininame);
 224 }
 225
 226
 227 WVTEST_MAIN("writing")
 228 {
 229     inicmp("/", "test",
 230            "/ = test\n");
 231
 232     inicmp("x/y", "z",
 233            "\n[x]\ny = z\n");
 234
 235     inicmp("x/y/z", "abc",
 236            "\n[x]\ny/z = abc\n");
 237
 238     inicmp("x\n/y/z", "abc",
 239            "\n[{x\n}]\ny/z = abc\n");
 240
 241     inicmp("/users/apenwarr", "{OBFU}scation!",
 242            "\n[users]\napenwarr = {OBFU}scation!\n");
 243
 244     inicmp("/users/ apenwarr", "pbc ",
 245            "\n[users]\n{ apenwarr} = {pbc }\n");
 246
 247     // FIXME: empty-string keys probably *should* be printed, but we don't,
 248     // for compatibility with WvConf.  This test makes sure it stays that
 249     // way (until we think of something better?)
 250     inicmp("/foo/blah", "",
 251            "");
 252 }
 253
 254
 255 static ino_t inode_of(const char *fname)
 256 {
 257     struct stat st;
 258     if (stat(fname, &st) != 0)
 259         return 0;
 260     else
 261         return st.st_ino;
 262 }
 263
 264
 265 static off_t size_of(const char *fname)
 266 {
 267     struct stat st;
 268     if (stat(fname, &st) != 0)
 269         return 0;
 270     else
 271         return st.st_size;
 272 }
 273
 274
 275 WVTEST_MAIN("atomic updates")
 276 {
 277     WvString dirname("atomic-update-dir.tmp"), fname("%s/test.ini", dirname);
 278     chmod(dirname, 0700);
 279     rm_rf(dirname);
 280     WVPASS(!mkdir(dirname, 0700)); // honours umask
 281     WVPASS(!chmod(dirname, 0700)); // doesn't include umask
 282
 283     // the directory is writable, so we can safely do atomic file replacement.
 284     // That means the file inode number will be *different* after doing
 285     // a second commit().
 286     UniConfRoot ini(WvString("ini:%s", fname));
 287     ini.xset("useless key", "useless value");
 288     ini.commit();
 289     ino_t inode1 = inode_of(fname);
 290     off_t size1 = size_of(fname);
 291     WVFAILEQ(inode1, 0);
 292     WVFAILEQ(size1, 0);
 293     ini.xset("1", "2");
 294     ini.commit();
 295     ino_t inode2 = inode_of(fname);
 296     off_t size2 = size_of(fname);
 297     WVFAILEQ(inode2, 0);
 298     WVFAILEQ(inode1, inode2);
 299     WVPASS(size2 > size1);
 300
 301     // now let's make the directory non-writable.  The inifile inside the
 302     // directory is still writable, which means we can update it, but not
 303     // atomically.  Therefore its inode number *won't* change.
 304     WVPASS(!chmod(dirname, 0500));
 305     ini.xset("3", "4");
 306     ini.commit();
 307     ino_t inode3 = inode_of(fname);
 308     off_t size3 = size_of(fname);
 309     WVFAILEQ(inode3, 0);
 310     WVPASSEQ(inode2, inode3);
 311     WVPASS(size3 > size2);
 312
 313     // clean up
 314     chmod(dirname, 0700);
 315     rm_rf(dirname);
 316 }
 317
 318
 319 WVTEST_MAIN("do not refresh if not requested")
 320 {
 321     WvString ininame = inigen("[foo]\n"
 322                               "bar = baz\n");
 323     UniConfRoot cfg(WvString("ini:%s", ininame), false);
 324
 325     WVFAIL(cfg["foo/bar"].exists());
 326     WVFAILEQ(cfg["foo/bar"].getme(), "baz");
 327     WVPASSEQ(childcount(cfg), 0);
 328
 329     ::unlink(ininame);
 330 }
 331