fix xml tokenizer tests

lib/ace/mode/html_highlight_rules_test.js

@@ -45,46 +45,146 @@ define(function(require, exports, module) {
 var HtmlMode = require("./html").Mode;
 var assert = require("../test/assertions");
 
+var testData = {
+    "test: tokenize embedded script" : [{
+        text: "<script a='a'>var</script>'123'",
+        state: ["start", "start"],
+        tokens: [{
+            type: "meta.tag",
+            value: "<"
+        }, {
+            type: "meta.tag.tag-name.script",
+            value: "script"
+        }, {
+            type: "text",
+            value: " "
+        }, {
+            type: "entity.other.attribute-name",
+            value: "a"
+        }, {
+            type: "keyword.operator",
+            value: "="
+        }, {
+            type: "string",
+            value: "'a'"
+        }, {
+            type: "meta.tag",
+            value: ">"
+        }, {
+            type: "storage.type",
+            value: "var"
+        }, {
+            type: "meta.tag",
+            value: "</"
+        }, {
+            type: "meta.tag.tag-name.script",
+            value: "script"
+        }, {
+            type: "meta.tag",
+            value: ">"
+        }, {
+            type: "text",
+            value: "'123'"
+        }]
+    }],
+
+    "test: tokenize multiline attribute value with double quotes": [{
+        text: "<a href=\"abc",
+        state: [ "start", "tag_qqstring"],
+        tokens: [{
+                type: "meta.tag",
+                value: "<"
+            }, {
+                type: "meta.tag.tag-name.anchor",
+                value: "a"
+            }, {
+                type: "text",
+                value: " "
+            }, {
+                type: "entity.other.attribute-name",
+                value: "href"
+            }, {
+                type: "keyword.operator",
+                value: "="
+            }, {
+                type: "string",
+                value: "\"abc"
+            }
+        ]
+    }, {
+        text: "def\">",
+        state: [ "tag_qqstring", "start" ],
+        tokens: [ {
+                type: "string",
+                value: "def\""
+            }, {
+                type: "meta.tag",
+                value: ">"
+            }
+        ]
+    }],
+
+    "test: tokenize multiline attribute value with single quotes": [{
+        text: "<a href='abc",
+        state: ["start", "tag_qstring"],
+        tokens: [{
+                type: "meta.tag",
+                value: "<"
+            }, {
+                type: "meta.tag.tag-name.anchor",
+                value: "a"
+            }, {
+                type: "text",
+                value: " "
+            }, {
+                type: "entity.other.attribute-name",
+                value: "href"
+            }, {
+                type: "keyword.operator",
+                value: "="
+            }, {
+                type: "string",
+                value: "'abc"
+            }
+        ]
+    }, {
+        text: "def\"'>",
+        state: [ "tag_qstring", "start" ],
+        tokens: [ {
+                type: "string",
+                value: "def\"'"
+            }, {
+                type: "meta.tag",
+                value: ">"
+            }
+        ]
+    }]
+};
+
+function generateTest(exampleData) {
+    return function testTokenizer() {
+        for (var i = 0; i < exampleData.length; i++) {
+            var s = exampleData[i];
+            var lineTokens = tokenizer.getLineTokens(s.text, s.state[0]);
+
+            assert.equal(
+                JSON.stringify(lineTokens, null, 4),
+                JSON.stringify({tokens:s.tokens, state: s.state[1]}, null, 4)
+            );
+        }
+    }
+}
+
+var tokenizer;
 module.exports = {
     setUp : function() {
-        this.tokenizer = new HtmlMode().getTokenizer();
+        tokenizer = new HtmlMode().getTokenizer();
-    },
-
-    "test: tokenize embedded script" : function() {
-        var line = "<script a='a'>var</script>'123'";
-        var tokens = this.tokenizer.getLineTokens(line, "start").tokens;
-
-        assert.equal(12, tokens.length);
-        assert.equal("meta.tag", tokens[0].type);
-        assert.equal("meta.tag.script", tokens[1].type);
-        assert.equal("text", tokens[2].type);
-        assert.equal("entity.other.attribute-name", tokens[3].type);
-        assert.equal("keyword.operator", tokens[4].type);
-        assert.equal("string", tokens[5].type);
-        assert.equal("meta.tag", tokens[6].type);
-        assert.equal("storage.type", tokens[7].type);
-        assert.equal("meta.tag", tokens[8].type);
-        assert.equal("meta.tag.script", tokens[9].type);
-        assert.equal("meta.tag", tokens[10].type);
-        assert.equal("text", tokens[11].type);
-    },
-    
-    "test: tokenize multiline attribute value with double quotes": function() {
-        var line1 = this.tokenizer.getLineTokens('<a href="abc', "start");
-        var t1 = line1.tokens;
-        var t2 = this.tokenizer.getLineTokens('def">', line1.state).tokens;
-        assert.equal(t1[t1.length-1].type, "string");
-        assert.equal(t2[0].type, "string");
-    },
-    
-    "test: tokenize multiline attribute value with single quotes": function() {
-        var line1 = this.tokenizer.getLineTokens("<a href='abc", "start");
-        var t1 = line1.tokens;
-        var t2 = this.tokenizer.getLineTokens('def\'>', line1.state).tokens;
-        assert.equal(t1[t1.length-1].type, "string");
-        assert.equal(t2[0].type, "string");
     }
-};
+}
+
+for (var i in testData) {
+    module.exports[i] = generateTest(testData[i])
+}
 
 });
 

lib/ace/mode/xml_highlight_rules_test.js

@@ -45,57 +45,169 @@ define(function(require, exports, module) {
 var XmlMode = require("./xml").Mode;
 var assert = require("../test/assertions");
 
-module.exports = {
+var testData = {
-    
+    "test: tokenize1" : [{
-    name: "XML Tokenizer",
+        text: "<Juhu>//Juhu Kinners</Kinners>",
-    
+        state: ["start", "start"],
-    setUp : function() {
+        tokens: [
-        this.tokenizer = new XmlMode().getTokenizer();
+            {
-    },
+                type: "meta.tag",
+                value: "<"
+            },
+            {
+                type: "meta.tag.tag-name",
+                value: "Juhu"
+            },
+            {
+                type: "meta.tag",
+                value: ">"
+            },
+            {
+                type: "text",
+                value: "//Juhu Kinners"
+            },
+            {
+                type: "meta.tag",
+                value: "</"
+            },
+            {
+                type: "meta.tag.tag-name",
+                value: "Kinners"
+            },
+            {
+                type: "meta.tag",
+                value: ">"
+            }
+        ]
+    }],
 
-    "test: tokenize1" : function() {
+    "test: two tags in the same lines should be in separate tokens": [{
-        var line = "<Juhu>//Juhu Kinners</Kinners>";
+        text: "<Juhu><Kinners>",
-        var tokens = this.tokenizer.getLineTokens(line, "start").tokens;
+        state: [ "start", "start"],
+        tokens: [
+            {
+                type: "meta.tag",
+                value: "<"
+            },
+            {
+                type: "meta.tag.tag-name",
+                value: "Juhu"
+            },
+            {
+                type: "meta.tag",
+                value: ">"
+            },
+            {
+                type: "meta.tag",
+                value: "<"
+            },
+            {
+                type: "meta.tag.tag-name",
+                value: "Kinners"
+            },
+            {
+                type: "meta.tag",
+                value: ">"
+            }
+        ]
+    }],
 
-        assert.equal(3, tokens.length);
+    "test: multiline attributes": [{
-        assert.equal("meta.tag", tokens[0].type);
+        text: "<copy set=\"{",
-        assert.equal("text", tokens[1].type);
+        state: ["start", "tag_qqstring"],
-        assert.equal("meta.tag", tokens[2].type);
+        tokens: [
-    },
+            {
-    
+                type: "meta.tag",
-    "test: two tags in the same lines should be in separate tokens" : function() {
+                value: "<"
-        var line = "<Juhu><Kinners>";
+            },
-        var tokens = this.tokenizer.getLineTokens(line, "start").tokens;
+            {
-
+                type: "meta.tag.tag-name",
-        assert.equal(2, tokens.length);
+                value: "copy"
-        assert.equal("meta.tag", tokens[0].type);
+            },
-        assert.equal("meta.tag", tokens[1].type);
+            {
-        
+                type: "text",
-        assert.equal("<Juhu>", tokens[0].value);
+                value: " "
-        assert.equal("<Kinners>", tokens[1].value);
+            },
-    },
+            {
-    
+                type: "entity.other.attribute-name",
-    "test: multiline attributes": function() {
+                value: "set"
-        var multiLine = ['<copy set="{', '}" undo="{', '}"/>'];
+            },
-        
+            {
-        var state = "start";
+                type: "keyword.operator",
-        var multiLineTokens = multiLine.map(function(line) {
+                value: "="
-            var tokens = this.tokenizer.getLineTokens(line, state);
+            },
-            state = tokens.state;
+            {
-            return tokens.tokens;
+                type: "string",
-        }, this);
+                value: "\"{"
-        
+            }
-        assert.equal(multiLineTokens[0].length, 5);
+        ]
-        assert.equal(multiLineTokens[1].length, 5);
+    }, {
-        assert.equal(multiLineTokens[2].length, 2);
+        text: "}\" undo=\"{",
-        
+        state: [ "tag_qqstring", "tag_qqstring"],
-        assert.equal(multiLineTokens[0][4].type, "string");
+        tokens: [
-        assert.equal(multiLineTokens[1][0].type, "string");
+            {
-        assert.equal(multiLineTokens[1][4].type, "string");
+                type: "string",
-        assert.equal(multiLineTokens[2][0].type, "string");
+                value: "}\""
-    }
+            },
+            {
+                type: "text",
+                value: " "
+            },
+            {
+                type: "entity.other.attribute-name",
+                value: "undo"
+            },
+            {
+                type: "keyword.operator",
+                value: "="
+            },
+            {
+                type: "string",
+                value: "\"{"
+            }
+        ]
+    }, {
+        text: "}\"/>",
+        state: ["tag_qqstring", "start"],
+        tokens: [
+            {
+                type: "string",
+                value: "}\""
+            },
+            {
+                type: "meta.tag",
+                value: "/>"
+            }
+        ]
+    }]
 };
 
+function generateTest(exampleData) {
+    return function testTokenizer() {
+        for (var i = 0; i < exampleData.length; i++) {
+            var s = exampleData[i];
+            var lineTokens = tokenizer.getLineTokens(s.text, s.state[0]);
+
+            assert.equal(
+                JSON.stringify(lineTokens, null, 4),
+                JSON.stringify({tokens:s.tokens, state: s.state[1]}, null, 4)
+            );
+        }
+    }
+}
+
+var tokenizer;
+module.exports = {
+    name: "XML Tokenizer",
+
+    setUp : function() {
+        tokenizer = new XmlMode().getTokenizer();
+    }
+}
+
+for (var i in testData) {
+    module.exports[i] = generateTest(testData[i])
+}
 });
 
 if (typeof module !== "undefined" && module === require.main) {