xpcom/tests/unit/test_iniProcessor.js

   1 const Ci = Components.interfaces;
   2 const Cc = Components.classes;
   3 const Cr = Components.results;
   4
   5 let testnum = 0;
   6 let factory;
   7
   8 function parserForFile(filename) {
   9     let parser = null;
  10     try {
  11         let file = do_get_file(filename);
  12         do_check_true(!!file);
  13         parser = factory.createINIParser(file);
  14         do_check_true(!!parser);
  15     } catch(e) {
  16         dump("INFO | caught error: " + e);
  17         // checkParserOutput will handle a null parser when it's expected.
  18     }
  19     return parser;
  20
  21 }
  22
  23 function checkParserOutput(parser, expected) {
  24     // If the expected output is null, we expect the parser to have
  25     // failed (and vice-versa).
  26     if (!parser || !expected) {
  27         do_check_eq(parser, null);
  28         do_check_eq(expected, null);
  29         return;
  30     }
  31
  32     let output = getParserOutput(parser);
  33     for (let section in expected) {
  34         do_check_true(section in output);
  35         for (let key in expected[section]) {
  36             do_check_true(key in output[section]);
  37             do_check_eq(output[section][key], expected[section][key]);
  38             delete output[section][key];
  39         }
  40         for (let key in output[section])
  41             do_check_eq(key, "wasn't expecting this key!");
  42         delete output[section];
  43     }
  44     for (let section in output)
  45         do_check_eq(section, "wasn't expecting this section!");
  46 }
  47
  48 function getParserOutput(parser) {
  49     let output = {};
  50
  51     let sections = parser.getSections();
  52     do_check_true(!!sections);
  53     while (sections.hasMore()) {
  54         let section = sections.getNext();
  55         do_check_false(section in output); // catch dupes
  56         output[section] = {};
  57
  58         let keys = parser.getKeys(section);
  59         do_check_true(!!keys);
  60         while (keys.hasMore()) {
  61             let key = keys.getNext();
  62             do_check_false(key in output[section]); // catch dupes
  63             let value = parser.getString(section, key);
  64             output[section][key] = value;
  65         }
  66     }
  67     return output;
  68 }
  69
  70 function run_test() {
  71 try {
  72
  73 let testdata = [
  74     { filename: "data/iniparser01.ini", reference: {} },
  75     { filename: "data/iniparser02.ini", reference: {} },
  76     { filename: "data/iniparser03.ini", reference: {} },
  77     { filename: "data/iniparser04.ini", reference: {} },
  78     { filename: "data/iniparser05.ini", reference: {} },
  79     { filename: "data/iniparser06.ini", reference: {} },
  80     { filename: "data/iniparser07.ini", reference: {} },
  81     { filename: "data/iniparser08.ini", reference: { section1: { name1: "" }} },
  82     { filename: "data/iniparser09.ini", reference: { section1: { name1: "value1" } } },
  83     { filename: "data/iniparser10.ini", reference: { section1: { name1: "value1" } } },
  84     { filename: "data/iniparser11.ini", reference: { section1: { name1: "value1" } } },
  85     { filename: "data/iniparser12.ini", reference: { section1: { name1: "value1" } } },
  86     { filename: "data/iniparser13.ini", reference: { section1: { name1: "value1" } } },
  87     { filename: "data/iniparser14.ini", reference:
  88                     { section1: { name1: "value1", name2: "value2" },
  89                       section2: { name1: "value1", name2: "foopy"  }} },
  90     { filename: "data/iniparser15.ini", reference:
  91                     { section1: { name1: "newValue1" },
  92                       section2: { name1: "foopy"     }} },
  93     ];
  94
  95 /* ========== 0 ========== */
  96 factory = Cc["@mozilla.org/xpcom/ini-processor-factory;1"].
  97           getService(Ci.nsIINIParserFactory);
  98 do_check_true(!!factory);
  99
 100 /* ========== 1 - 15 ========== */
 101
 102 // Test reading from a variety of files. While we're at it, write out each one
 103 // and read it back to ensure that nothing changed.
 104 for (testnum = 1; testnum <= 15; testnum++) {
 105     let filename = testdata[testnum -1].filename;
 106     dump("INFO | test #" + testnum + ", filename " + filename + "\n");
 107     let parser = parserForFile(filename);
 108     checkParserOutput(parser, testdata[testnum - 1].reference);
 109     if (!parser)
 110         continue;
 111     do_check_true(parser instanceof Ci.nsIINIParserWriter);
 112     // write contents out to a new file
 113     let newfilename = filename + ".new";
 114     let newfile = do_get_file(filename);
 115     newfile.leafName += ".new";
 116     parser.writeFile(newfile);
 117     // read new file and make sure the contents are the same.
 118     parser = parserForFile(newfilename);
 119     checkParserOutput(parser, testdata[testnum - 1].reference);
 120 }
 121
 122 /* ========== 16 ========== */
 123
 124 // test writing to a new file.
 125 let newfile = do_get_file("data/");
 126 newfile.append("nonexistent-file.ini");
 127 if (newfile.exists())
 128     newfile.remove(false);
 129 do_check_false(newfile.exists());
 130
 131 let parser = factory.createINIParser(newfile);
 132 do_check_true(!!parser);
 133 do_check_true(parser instanceof Ci.nsIINIParserWriter);
 134 checkParserOutput(parser, {});
 135 parser.writeFile();
 136 do_check_true(newfile.exists());
 137
 138 // test adding a new section and new key
 139 parser.setString("section", "key", "value");
 140 parser.writeFile();
 141 do_check_true(newfile.exists());
 142 checkParserOutput(parser, {section: {key: "value"} });
 143 // read it in again, check for same data.
 144 parser = parserForFile("data/nonexistent-file.ini");
 145 checkParserOutput(parser, {section: {key: "value"} });
 146
 147 /* ========== 17 ========== */
 148
 149 // test modifying a existing key's value (in an existing section)
 150 parser = parserForFile("data/iniparser09.ini");
 151 checkParserOutput(parser, {section1: {name1: "value1"} });
 152
 153 do_check_true(parser instanceof Ci.nsIINIParserWriter);
 154 parser.setString("section1", "name1", "value2");
 155 checkParserOutput(parser, {section1: {name1: "value2"} });
 156
 157 /* ========== 18 ========== */
 158
 159 // test trying to set illegal characters
 160 let caughtError;
 161 caughtError = false;
 162 checkParserOutput(parser, {section1: {name1: "value2"} });
 163
 164 // Bad characters in section name
 165 try { parser.SetString("bad\0", "ok", "ok"); } catch (e) { caughtError = true; }
 166 do_check_true(caughtError);
 167 caughtError = false;
 168 try { parser.SetString("bad\r", "ok", "ok"); } catch (e) { caughtError = true; }
 169 do_check_true(caughtError);
 170 caughtError = false;
 171 try { parser.SetString("bad\n", "ok", "ok"); } catch (e) { caughtError = true; }
 172 do_check_true(caughtError);
 173 caughtError = false;
 174 try { parser.SetString("bad[", "ok", "ok"); } catch (e) { caughtError = true; }
 175 do_check_true(caughtError);
 176 caughtError = false;
 177 try { parser.SetString("bad]", "ok", "ok"); } catch (e) { caughtError = true; }
 178 do_check_true(caughtError);
 179
 180 // Bad characters in key name
 181 caughtError = false;
 182 try { parser.SetString("ok", "bad\0", "ok"); } catch (e) { caughtError = true; }
 183 do_check_true(caughtError);
 184 caughtError = false;
 185 try { parser.SetString("ok", "bad\r", "ok"); } catch (e) { caughtError = true; }
 186 do_check_true(caughtError);
 187 caughtError = false;
 188 try { parser.SetString("ok", "bad\n", "ok"); } catch (e) { caughtError = true; }
 189 do_check_true(caughtError);
 190 caughtError = false;
 191 try { parser.SetString("ok", "bad=", "ok"); } catch (e) { caughtError = true; }
 192 do_check_true(caughtError);
 193
 194 // Bad characters in value
 195 caughtError = false;
 196 try { parser.SetString("ok", "ok", "bad\0"); } catch (e) { caughtError = true; }
 197 do_check_true(caughtError);
 198 caughtError = false;
 199 try { parser.SetString("ok", "ok", "bad\r"); } catch (e) { caughtError = true; }
 200 do_check_true(caughtError);
 201 caughtError = false;
 202 try { parser.SetString("ok", "ok", "bad\n"); } catch (e) { caughtError = true; }
 203 do_check_true(caughtError);
 204 caughtError = false;
 205 try { parser.SetString("ok", "ok", "bad="); } catch (e) { caughtError = true; }
 206 do_check_true(caughtError);
 207
 208 } catch(e) {
 209     throw "FAILED in test #" + testnum + " -- " + e;
 210 }
 211 }