.config/coc/extensions/node_modules/coc-prettier/node_modules/entities/test/test.js

   1 var assert = require("assert"),
   2     path = require("path"),
   3     entities = require("../");
   4
   5 describe("Encode->decode test", function() {
   6     var testcases = [
   7         {
   8             input: "asdf & ÿ ü '",
   9             xml: "asdf &amp; &#xFF; &#xFC; &apos;",
  10             html: "asdf &amp; &yuml; &uuml; &apos;"
  11         },
  12         {
  13             input: "&#38;",
  14             xml: "&amp;#38;",
  15             html: "&amp;&num;38&semi;"
  16         }
  17     ];
  18     testcases.forEach(function(tc) {
  19         var encodedXML = entities.encodeXML(tc.input);
  20         it("should XML encode " + tc.input, function() {
  21             assert.equal(encodedXML, tc.xml);
  22         });
  23         it("should default to XML encode " + tc.input, function() {
  24             assert.equal(entities.encode(tc.input), tc.xml);
  25         });
  26         it("should XML decode " + encodedXML, function() {
  27             assert.equal(entities.decodeXML(encodedXML), tc.input);
  28         });
  29         it("should default to XML encode " + encodedXML, function() {
  30             assert.equal(entities.decode(encodedXML), tc.input);
  31         });
  32         it("should default strict to XML encode " + encodedXML, function() {
  33             assert.equal(entities.decodeStrict(encodedXML), tc.input);
  34         });
  35
  36         var encodedHTML5 = entities.encodeHTML5(tc.input);
  37         it("should HTML5 encode " + tc.input, function() {
  38             assert.equal(encodedHTML5, tc.html);
  39         });
  40         it("should HTML5 decode " + encodedHTML5, function() {
  41             assert.equal(entities.decodeHTML(encodedHTML5), tc.input);
  42         });
  43     });
  44
  45     it("should encode data URIs (issue 16)", function() {
  46         var data = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAALAAABAAEAAAIBRAA7";
  47         assert.equal(entities.decode(entities.encode(data)), data);
  48     });
  49 });
  50
  51 describe("Decode test", function() {
  52     var testcases = [
  53         { input: "&amp;amp;", output: "&amp;" },
  54         { input: "&amp;#38;", output: "&#38;" },
  55         { input: "&amp;#x26;", output: "&#x26;" },
  56         { input: "&amp;#X26;", output: "&#X26;" },
  57         { input: "&#38;#38;", output: "&#38;" },
  58         { input: "&#x26;#38;", output: "&#38;" },
  59         { input: "&#X26;#38;", output: "&#38;" },
  60         { input: "&#x3a;", output: ":" },
  61         { input: "&#x3A;", output: ":" },
  62         { input: "&#X3a;", output: ":" },
  63         { input: "&#X3A;", output: ":" }
  64     ];
  65     testcases.forEach(function(tc) {
  66         it("should XML decode " + tc.input, function() {
  67             assert.equal(entities.decodeXML(tc.input), tc.output);
  68         });
  69         it("should HTML4 decode " + tc.input, function() {
  70             assert.equal(entities.decodeHTML(tc.input), tc.output);
  71         });
  72         it("should HTML5 decode " + tc.input, function() {
  73             assert.equal(entities.decodeHTML(tc.input), tc.output);
  74         });
  75     });
  76 });
  77
  78 var levels = ["xml", "entities"];
  79
  80 describe("Documents", function() {
  81     levels
  82         .map(function(n) {
  83             return path.join("..", "maps", n);
  84         })
  85         .map(require)
  86         .forEach(function(doc, i) {
  87             describe("Decode", function() {
  88                 it(levels[i], function() {
  89                     Object.keys(doc).forEach(function(e) {
  90                         for (var l = i; l < levels.length; l++) {
  91                             assert.equal(entities.decode("&" + e + ";", l), doc[e]);
  92                         }
  93                     });
  94                 });
  95             });
  96
  97             describe("Decode strict", function() {
  98                 it(levels[i], function() {
  99                     Object.keys(doc).forEach(function(e) {
 100                         for (var l = i; l < levels.length; l++) {
 101                             assert.equal(entities.decodeStrict("&" + e + ";", l), doc[e]);
 102                         }
 103                     });
 104                 });
 105             });
 106
 107             describe("Encode", function() {
 108                 it(levels[i], function() {
 109                     Object.keys(doc).forEach(function(e) {
 110                         for (var l = i; l < levels.length; l++) {
 111                             assert.equal(entities.decode(entities.encode(doc[e], l), l), doc[e]);
 112                         }
 113                     });
 114                 });
 115             });
 116         });
 117
 118     var legacy = require("../maps/legacy.json");
 119
 120     describe("Legacy", function() {
 121         it("should decode", runLegacy);
 122     });
 123
 124     function runLegacy() {
 125         Object.keys(legacy).forEach(function(e) {
 126             assert.equal(entities.decodeHTML("&" + e), legacy[e]);
 127         });
 128     }
 129 });
 130
 131 var astral = {
 132     "1D306": "\uD834\uDF06",
 133     "1D11E": "\uD834\uDD1E"
 134 };
 135
 136 var astralSpecial = {
 137     "80": "\u20AC",
 138     "110000": "\uFFFD"
 139 };
 140
 141 describe("Astral entities", function() {
 142     Object.keys(astral).forEach(function(c) {
 143         it("should decode " + astral[c], function() {
 144             assert.equal(entities.decode("&#x" + c + ";"), astral[c]);
 145         });
 146
 147         it("should encode " + astral[c], function() {
 148             assert.equal(entities.encode(astral[c]), "&#x" + c + ";");
 149         });
 150
 151         it("should escape " + astral[c], function() {
 152             assert.equal(entities.escape(astral[c]), "&#x" + c + ";");
 153         });
 154     });
 155
 156     Object.keys(astralSpecial).forEach(function(c) {
 157         it("special should decode \\u" + c, function() {
 158             assert.equal(entities.decode("&#x" + c + ";"), astralSpecial[c]);
 159         });
 160     });
 161 });
 162
 163 describe("Escape", function() {
 164     it("should always decode ASCII chars", function() {
 165         for (var i = 0; i < 0x7f; i++) {
 166             var c = String.fromCharCode(i);
 167             assert.equal(entities.decodeXML(entities.escape(c)), c);
 168         }
 169     });
 170 });