1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/accessible/tests/mochitest/name/markup.js Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,382 @@
1.4 +////////////////////////////////////////////////////////////////////////////////
1.5 +// Name tests described by "markuprules.xml" file.
1.6 +
1.7 +var gNameRulesFileURL = "markuprules.xml";
1.8 +
1.9 +var gRuleDoc = null;
1.10 +
1.11 +// Debuggin stuff.
1.12 +var gDumpToConsole = false;
1.13 +
1.14 +/**
1.15 + * Start name tests. Run through markup elements and test names for test
1.16 + * element (see namerules.xml for details).
1.17 + */
1.18 +function testNames()
1.19 +{
1.20 + //enableLogging("tree,stack"); // debugging
1.21 +
1.22 + var request = new XMLHttpRequest();
1.23 + request.open("get", gNameRulesFileURL, false);
1.24 + request.send();
1.25 +
1.26 + gRuleDoc = request.responseXML;
1.27 +
1.28 + var markupElms = evaluateXPath(gRuleDoc, "//rules/rulesample/markup");
1.29 + gTestIterator.iterateMarkups(markupElms);
1.30 +}
1.31 +
1.32 +////////////////////////////////////////////////////////////////////////////////
1.33 +// Private section.
1.34 +
1.35 +/**
1.36 + * Helper class to interate through name tests.
1.37 + */
1.38 +var gTestIterator =
1.39 +{
1.40 + iterateMarkups: function gTestIterator_iterateMarkups(aMarkupElms)
1.41 + {
1.42 + this.markupElms = aMarkupElms;
1.43 +
1.44 + this.iterateNext();
1.45 + },
1.46 +
1.47 + iterateRules: function gTestIterator_iterateRules(aElm, aContainer,
1.48 + aRuleSetElm, aRuleElms,
1.49 + aTestID)
1.50 + {
1.51 + this.ruleSetElm = aRuleSetElm;
1.52 + this.ruleElms = aRuleElms;
1.53 + this.elm = aElm;
1.54 + this.container = aContainer;
1.55 + this.testID = aTestID;
1.56 +
1.57 + this.iterateNext();
1.58 + },
1.59 +
1.60 + iterateNext: function gTestIterator_iterateNext()
1.61 + {
1.62 + if (this.markupIdx == -1) {
1.63 + this.markupIdx++;
1.64 + testNamesForMarkup(this.markupElms[this.markupIdx]);
1.65 + return;
1.66 + }
1.67 +
1.68 + this.ruleIdx++;
1.69 + if (this.ruleIdx == this.ruleElms.length) {
1.70 + // When test is finished then name is empty and no explict-name.
1.71 + var defaultName = this.ruleSetElm.hasAttribute("defaultName") ?
1.72 + this.ruleSetElm.getAttribute("defaultName") : null;
1.73 + testName(this.elm, defaultName,
1.74 + "Default name test (" + gTestIterator.testID + "). ");
1.75 + testAbsentAttrs(this.elm, {"explicit-name" : "true"});
1.76 +
1.77 + this.markupIdx++;
1.78 + if (this.markupIdx == this.markupElms.length) {
1.79 + //disableLogging("tree"); // debugging
1.80 + SimpleTest.finish();
1.81 + return;
1.82 + }
1.83 +
1.84 + this.ruleIdx = -1;
1.85 +
1.86 + if (gDumpToConsole) {
1.87 + dump("\nPend next markup processing. Wait for reorder event on " +
1.88 + prettyName(document) + "'\n");
1.89 + }
1.90 + waitForEvent(EVENT_REORDER, document, testNamesForMarkup,
1.91 + null, this.markupElms[this.markupIdx]);
1.92 +
1.93 + document.body.removeChild(this.container);
1.94 + return;
1.95 + }
1.96 +
1.97 + testNameForRule(this.elm, this.ruleElms[this.ruleIdx]);
1.98 + },
1.99 +
1.100 + markupElms: null,
1.101 + markupIdx: -1,
1.102 + rulesetElm: null,
1.103 + ruleElms: null,
1.104 + ruleIdx: -1,
1.105 + elm: null,
1.106 + container: null,
1.107 + testID: ""
1.108 +};
1.109 +
1.110 +/**
1.111 + * Process every 'markup' element and test names for it. Used by testNames
1.112 + * function.
1.113 + */
1.114 +function testNamesForMarkup(aMarkupElm)
1.115 +{
1.116 + if (gDumpToConsole)
1.117 + dump("\nProcessing markup '" + aMarkupElm.getAttribute("id") + "'\n");
1.118 +
1.119 + var div = document.createElement("div");
1.120 + div.setAttribute("id", "test");
1.121 +
1.122 + var child = aMarkupElm.firstChild;
1.123 + while (child) {
1.124 + var newChild = document.importNode(child, true);
1.125 + div.appendChild(newChild);
1.126 + child = child.nextSibling;
1.127 + }
1.128 +
1.129 + if (gDumpToConsole) {
1.130 + dump("\nProcessing markup. Wait for reorder event on " +
1.131 + prettyName(document) + "'\n");
1.132 + }
1.133 + waitForEvent(EVENT_REORDER, document, testNamesForMarkupRules,
1.134 + null, aMarkupElm, div);
1.135 +
1.136 + document.body.appendChild(div);
1.137 +}
1.138 +
1.139 +function testNamesForMarkupRules(aMarkupElm, aContainer)
1.140 +{
1.141 + var testID = aMarkupElm.getAttribute("id");
1.142 + if (gDumpToConsole)
1.143 + dump("\nProcessing markup rules '" + testID + "'\n");
1.144 +
1.145 + var serializer = new XMLSerializer();
1.146 +
1.147 + var expr = "//html/body/div[@id='test']/" + aMarkupElm.getAttribute("ref");
1.148 + var elm = evaluateXPath(document, expr, htmlDocResolver)[0];
1.149 +
1.150 + var ruleId = aMarkupElm.getAttribute("ruleset");
1.151 + var ruleElm = gRuleDoc.querySelector("[id='" + ruleId + "']");
1.152 + var ruleElms = getRuleElmsByRulesetId(ruleId);
1.153 +
1.154 + var processMarkupRules =
1.155 + gTestIterator.iterateRules.bind(gTestIterator, elm, aContainer,
1.156 + ruleElm, ruleElms, testID);
1.157 +
1.158 + // Images may be recreated after we append them into subtree. We need to wait
1.159 + // in this case. If we are on profiling enabled build then stack tracing
1.160 + // works and thus let's log instead. Note, that works if you enabled logging
1.161 + // (refer to testNames() function).
1.162 + if (isAccessible(elm) || isLogged("stack"))
1.163 + processMarkupRules();
1.164 + else
1.165 + waitForEvent(EVENT_SHOW, elm, processMarkupRules);
1.166 +}
1.167 +
1.168 +/**
1.169 + * Test name for current rule and current 'markup' element. Used by
1.170 + * testNamesForMarkup function.
1.171 + */
1.172 +function testNameForRule(aElm, aRuleElm)
1.173 +{
1.174 + if (aRuleElm.hasAttribute("attr")) {
1.175 + if (gDumpToConsole) {
1.176 + dump("\nProcessing rule { attr: " + aRuleElm.getAttribute("attr") +" }\n");
1.177 + }
1.178 +
1.179 + testNameForAttrRule(aElm, aRuleElm);
1.180 +
1.181 + } else if (aRuleElm.hasAttribute("elm")) {
1.182 + if (gDumpToConsole) {
1.183 + dump("\nProcessing rule { elm: " + aRuleElm.getAttribute("elm") +
1.184 + ", elmattr: " + aRuleElm.getAttribute("elmattr") +" }\n");
1.185 + }
1.186 +
1.187 + testNameForElmRule(aElm, aRuleElm);
1.188 +
1.189 + } else if (aRuleElm.getAttribute("fromsubtree") == "true") {
1.190 + if (gDumpToConsole) {
1.191 + dump("\nProcessing rule { fromsubtree: " +
1.192 + aRuleElm.getAttribute("fromsubtree") +" }\n");
1.193 + }
1.194 +
1.195 + testNameForSubtreeRule(aElm, aRuleElm);
1.196 + }
1.197 +}
1.198 +
1.199 +function testNameForAttrRule(aElm, aRule)
1.200 +{
1.201 + var name = "";
1.202 +
1.203 + var attr = aRule.getAttribute("attr");
1.204 + var attrValue = aElm.getAttribute(attr);
1.205 +
1.206 + var type = aRule.getAttribute("type");
1.207 + if (type == "string") {
1.208 + name = attrValue;
1.209 +
1.210 + } else if (type == "ref" && attrValue) {
1.211 + var ids = attrValue.split(/\s+/);
1.212 + for (var idx = 0; idx < ids.length; idx++) {
1.213 + var labelElm = getNode(ids[idx]);
1.214 + if (name != "")
1.215 + name += " ";
1.216 +
1.217 + name += labelElm.getAttribute("textequiv");
1.218 + }
1.219 + }
1.220 +
1.221 + var msg = "Attribute '" + attr + "' test (" + gTestIterator.testID + "). ";
1.222 + testName(aElm, name, msg);
1.223 +
1.224 + if (aRule.getAttribute("explict-name") != "false")
1.225 + testAttrs(aElm, {"explicit-name" : "true"}, true);
1.226 + else
1.227 + testAbsentAttrs(aElm, {"explicit-name" : "true"});
1.228 +
1.229 + // If @recreated attribute is used then this attribute change recreates an
1.230 + // accessible. Wait for reorder event in this case or otherwise proceed next
1.231 + // test immediately.
1.232 + if (aRule.hasAttribute("recreated")) {
1.233 + waitForEvent(EVENT_REORDER, aElm.parentNode,
1.234 + gTestIterator.iterateNext, gTestIterator);
1.235 + aElm.removeAttribute(attr);
1.236 +
1.237 + } else if (aRule.hasAttribute("textchanged")) {
1.238 + waitForEvent(EVENT_TEXT_INSERTED, aElm,
1.239 + gTestIterator.iterateNext, gTestIterator);
1.240 + aElm.removeAttribute(attr);
1.241 +
1.242 + } else if (aRule.hasAttribute("contentchanged")) {
1.243 + waitForEvent(EVENT_REORDER, aElm,
1.244 + gTestIterator.iterateNext, gTestIterator);
1.245 + aElm.removeAttribute(attr);
1.246 +
1.247 + } else {
1.248 + aElm.removeAttribute(attr);
1.249 + gTestIterator.iterateNext();
1.250 + }
1.251 +}
1.252 +
1.253 +function testNameForElmRule(aElm, aRule)
1.254 +{
1.255 + var labelElm;
1.256 +
1.257 + var tagname = aRule.getAttribute("elm");
1.258 + var attrname = aRule.getAttribute("elmattr");
1.259 + if (attrname) {
1.260 + var filter = {
1.261 + acceptNode: function filter_acceptNode(aNode)
1.262 + {
1.263 + if (aNode.localName == this.mLocalName &&
1.264 + aNode.getAttribute(this.mAttrName) == this.mAttrValue)
1.265 + return NodeFilter.FILTER_ACCEPT;
1.266 +
1.267 + return NodeFilter.FILTER_SKIP;
1.268 + },
1.269 +
1.270 + mLocalName: tagname,
1.271 + mAttrName: attrname,
1.272 + mAttrValue: aElm.getAttribute("id")
1.273 + };
1.274 +
1.275 + var treeWalker = document.createTreeWalker(document.body,
1.276 + NodeFilter.SHOW_ELEMENT,
1.277 + filter);
1.278 + labelElm = treeWalker.nextNode();
1.279 +
1.280 + } else {
1.281 + // if attrname is empty then look for the element in subtree.
1.282 + labelElm = aElm.getElementsByTagName(tagname)[0];
1.283 + if (!labelElm)
1.284 + labelElm = aElm.getElementsByTagName("html:" + tagname)[0];
1.285 + }
1.286 +
1.287 + if (!labelElm) {
1.288 + ok(false, msg + " Failed to find '" + tagname + "' element.");
1.289 + gTestIterator.iterateNext();
1.290 + return;
1.291 + }
1.292 +
1.293 + var msg = "Element '" + tagname + "' test (" + gTestIterator.testID + ").";
1.294 + testName(aElm, labelElm.getAttribute("textequiv"), msg);
1.295 + testAttrs(aElm, {"explicit-name" : "true"}, true);
1.296 +
1.297 + var parentNode = labelElm.parentNode;
1.298 +
1.299 + if (gDumpToConsole) {
1.300 + dump("\nProcessed elm rule. Wait for reorder event on " +
1.301 + prettyName(parentNode) + "\n");
1.302 + }
1.303 + waitForEvent(EVENT_REORDER, parentNode,
1.304 + gTestIterator.iterateNext, gTestIterator);
1.305 +
1.306 + parentNode.removeChild(labelElm);
1.307 +}
1.308 +
1.309 +function testNameForSubtreeRule(aElm, aRule)
1.310 +{
1.311 + var msg = "From subtree test (" + gTestIterator.testID + ").";
1.312 + testName(aElm, aElm.getAttribute("textequiv"), msg);
1.313 + testAbsentAttrs(aElm, {"explicit-name" : "true"});
1.314 +
1.315 + if (gDumpToConsole) {
1.316 + dump("\nProcessed from subtree rule. Wait for reorder event on " +
1.317 + prettyName(aElm) + "\n");
1.318 + }
1.319 + waitForEvent(EVENT_REORDER, aElm, gTestIterator.iterateNext, gTestIterator);
1.320 +
1.321 + while (aElm.firstChild)
1.322 + aElm.removeChild(aElm.firstChild);
1.323 +}
1.324 +
1.325 +/**
1.326 + * Return array of 'rule' elements. Used in conjunction with
1.327 + * getRuleElmsFromRulesetElm() function.
1.328 + */
1.329 +function getRuleElmsByRulesetId(aRulesetId)
1.330 +{
1.331 + var expr = "//rules/ruledfn/ruleset[@id='" + aRulesetId + "']";
1.332 + var rulesetElm = evaluateXPath(gRuleDoc, expr);
1.333 + return getRuleElmsFromRulesetElm(rulesetElm[0]);
1.334 +}
1.335 +
1.336 +function getRuleElmsFromRulesetElm(aRulesetElm)
1.337 +{
1.338 + var rulesetId = aRulesetElm.getAttribute("ref");
1.339 + if (rulesetId)
1.340 + return getRuleElmsByRulesetId(rulesetId);
1.341 +
1.342 + var ruleElms = [];
1.343 +
1.344 + var child = aRulesetElm.firstChild;
1.345 + while (child) {
1.346 + if (child.localName == "ruleset")
1.347 + ruleElms = ruleElms.concat(getRuleElmsFromRulesetElm(child));
1.348 + if (child.localName == "rule")
1.349 + ruleElms.push(child);
1.350 +
1.351 + child = child.nextSibling;
1.352 + }
1.353 +
1.354 + return ruleElms;
1.355 +}
1.356 +
1.357 +/**
1.358 + * Helper method to evaluate xpath expression.
1.359 + */
1.360 +function evaluateXPath(aNode, aExpr, aResolver)
1.361 +{
1.362 + var xpe = new XPathEvaluator();
1.363 +
1.364 + var resolver = aResolver;
1.365 + if (!resolver) {
1.366 + var node = aNode.ownerDocument == null ?
1.367 + aNode.documentElement : aNode.ownerDocument.documentElement;
1.368 + resolver = xpe.createNSResolver(node);
1.369 + }
1.370 +
1.371 + var result = xpe.evaluate(aExpr, aNode, resolver, 0, null);
1.372 + var found = [];
1.373 + var res;
1.374 + while (res = result.iterateNext())
1.375 + found.push(res);
1.376 +
1.377 + return found;
1.378 +}
1.379 +
1.380 +function htmlDocResolver(aPrefix) {
1.381 + var ns = {
1.382 + 'html' : 'http://www.w3.org/1999/xhtml'
1.383 + };
1.384 + return ns[aPrefix] || null;
1.385 +}
