Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code

Delta Between Two Patch Sets: test/browser/elemHideEmulation.js

Issue 29383960: Issue 3143 - Filter elements with :-abp-has() (Closed) Base URL: https://hg.adblockplus.org/adblockpluscore
Left Patch Set: More cleanup, more robust tests Created March 22, 2017, 2:42 p.m.
Right Patch Set: Fix reportError and the error message Created June 13, 2017, 1:52 p.m.
Left:
Right:
Use n/p to move between diff chunks; N/P to move between comments.
Jump to:
Left: Side by side diff | Download
Right: Side by side diff | Download
« no previous file with change/comment | « chrome/content/elemHideEmulation.js ('k') | no next file » | no next file with change/comment »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
LEFTRIGHT
1 /* 1 /*
2 * This file is part of Adblock Plus <https://adblockplus.org/>, 2 * This file is part of Adblock Plus <https://adblockplus.org/>,
3 * Copyright (C) 2006-2017 eyeo GmbH 3 * Copyright (C) 2006-2017 eyeo GmbH
4 * 4 *
5 * Adblock Plus is free software: you can redistribute it and/or modify 5 * Adblock Plus is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 3 as 6 * it under the terms of the GNU General Public License version 3 as
7 * published by the Free Software Foundation. 7 * published by the Free Software Foundation.
8 * 8 *
9 * Adblock Plus is distributed in the hope that it will be useful, 9 * Adblock Plus is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details. 12 * GNU General Public License for more details.
13 * 13 *
14 * You should have received a copy of the GNU General Public License 14 * You should have received a copy of the GNU General Public License
15 * along with Adblock Plus. If not, see <http://www.gnu.org/licenses/>. 15 * along with Adblock Plus. If not, see <http://www.gnu.org/licenses/>.
16 */ 16 */
17 17
18 // We are currently limited to ECMAScript 5 in this file, because it is being 18 "use strict";
19 // used in the browser tests. See https://issues.adblockplus.org/ticket/4796 19
20 20 /* globals ElemHideEmulation, splitSelector,
21 // TODO: This should be using document.currentScript once supported by 21 parseSelectorContent,
22 // PhantomJS. 22 parseSelector, positionInParent, makeSelector,
23 var myUrl = document.head.lastChild.src; 23 PlainSelector, HasSelector, PropsSelector */
24 24
25 exports.setUp = function(callback) 25 let myUrl = document.currentScript.src;
26 {
27 // The URL object in PhantomJS 2.1.7 does not implement any properties, so
28 // we need a polyfill.
29 if (!URL || !("origin" in URL))
30 {
31 var doc = document.implementation.createHTMLDocument();
32 var anchor = doc.createElement("a");
33 doc.body.appendChild(anchor);
34 URL = function(url)
35 {
36 if (!url)
37 throw "Invalid URL";
38 anchor.href = url;
39 this.origin = anchor.origin;
40 };
41 }
42
43 callback();
44 };
45 26
46 exports.tearDown = function(callback) 27 exports.tearDown = function(callback)
47 { 28 {
48 var styleElements = document.head.getElementsByTagName("style"); 29 let styleElements = document.head.getElementsByTagName("style");
49 while (styleElements.length) 30 while (styleElements.length)
50 styleElements[0].parentNode.removeChild(styleElements[0]); 31 styleElements[0].parentNode.removeChild(styleElements[0]);
51 var child; 32
52 while(child = document.body.firstChild) 33 let child;
53 { 34 while (child = document.body.firstChild)
54 document.body.removeChild(child); 35 child.parentNode.removeChild(child);
55 } 36
56 callback(); 37 callback();
57 }; 38 };
39
40 function unexpectedError(error)
41 {
42 console.error(error);
43 this.ok(false, "Unexpected error: " + error);
44 }
58 45
59 function expectHidden(test, element) 46 function expectHidden(test, element)
60 { 47 {
61 test.equal(window.getComputedStyle(element).display, "none", 48 test.equal(window.getComputedStyle(element).display, "none",
62 "The element's display property should be set to 'none'"); 49 "The element's display property should be set to 'none'");
63 } 50 }
64 51
65 function expectVisible(test, element) 52 function expectVisible(test, element)
66 { 53 {
67 test.notEqual(window.getComputedStyle(element).display, "none", 54 test.notEqual(window.getComputedStyle(element).display, "none",
68 "The element's display property should not be set to 'none'"); 55 "The element's display property should not be set to 'none'");
69 } 56 }
70 57
71 function findUniqueId() 58 function findUniqueId()
72 { 59 {
73 var id = "elemHideEmulationTest-" + Math.floor(Math.random() * 10000); 60 let id = "elemHideEmulationTest-" + Math.floor(Math.random() * 10000);
74 if (!document.getElementById(id)) 61 if (!document.getElementById(id))
75 return id; 62 return id;
76 return findUniqueId(); 63 return findUniqueId();
77 } 64 }
78 65
79 function insertStyleRule(rule) 66 function insertStyleRule(rule)
80 { 67 {
81 var styleElement; 68 let styleElement;
82 var styleElements = document.head.getElementsByTagName("style"); 69 let styleElements = document.head.getElementsByTagName("style");
83 if (styleElements.length) 70 if (styleElements.length)
84 styleElement = styleElements[0]; 71 styleElement = styleElements[0];
85 else 72 else
86 { 73 {
87 styleElement = document.createElement("style"); 74 styleElement = document.createElement("style");
88 document.head.appendChild(styleElement); 75 document.head.appendChild(styleElement);
89 } 76 }
90 styleElement.sheet.insertRule(rule, styleElement.sheet.cssRules.length); 77 styleElement.sheet.insertRule(rule, styleElement.sheet.cssRules.length);
91 } 78 }
92 79
93 // insert a <div> with a unique id and and empty CSS rule 80 // insert a <div> with a unique id and a CSS rule
94 // for the the selector matching the id. 81 // for the the selector matching the id.
95 function createElementWithStyle(styleBlock, parent) 82 function createElementWithStyle(styleBlock, parent)
96 { 83 {
97 var element = document.createElement("div"); 84 let element = document.createElement("div");
98 element.id = findUniqueId(); 85 element.id = findUniqueId();
99 if (!parent) 86 if (!parent)
100 document.body.appendChild(element); 87 document.body.appendChild(element);
101 else 88 else
102 parent.appendChild(element); 89 parent.appendChild(element);
103 insertStyleRule("#" + element.id + " " + styleBlock); 90 insertStyleRule("#" + element.id + " " + styleBlock);
104 return element; 91 return element;
105 } 92 }
106 93
107 // Will ensure the class ElemHideEmulation is loaded 94 // Will ensure the class ElemHideEmulation is loaded.
108 // and then will call the callback. 95 // NOTE: if it never loads, this will probably hang.
109 // NOTE: if it never loads, this will probably hang in an infinite 96 function loadElemHideEmulation()
110 // loop
111 function loadElemHideEmulation(callback)
112 { 97 {
113 if (typeof ElemHideEmulation == "undefined") 98 if (typeof ElemHideEmulation == "undefined")
114 { 99 {
115 loadScript(myUrl + "/../../../lib/common.js", function() 100 return loadScript(myUrl + "/../../../lib/common.js").then(() =>
116 { 101 {
117 loadScript(myUrl + "/../../../chrome/content/elemHideEmulation.js", 102 return loadScript(myUrl + "/../../../chrome/content/elemHideEmulation.js") ;
118 function() 103 }).then(() =>
119 { 104 {
120 loadElemHideEmulation(callback); 105 return loadElemHideEmulation();
121 });
122 }); 106 });
123 return;
124 } 107 }
125 108
126 callback(); 109 return Promise.resolve();
127 } 110 }
128 111
129 // instantiate a ElemHideEmulation with @selectors. 112 // Create a new ElemHideEmulation instance with @selectors.
130 function applyElemHideEmulation(selectors, callback) 113 function applyElemHideEmulation(selectors)
131 { 114 {
132 loadElemHideEmulation(function() 115 return loadElemHideEmulation().then(() =>
133 { 116 {
134 var elemHideEmulation = new ElemHideEmulation( 117 let elemHideEmulation = new ElemHideEmulation(
135 window, 118 window,
136 function(callback) 119 callback =>
137 { 120 {
138 var patterns = []; 121 let patterns = [];
139 selectors.forEach(function(selector) 122 selectors.forEach(selector =>
140 { 123 {
141 patterns.push({selector: selector}); 124 patterns.push({selector});
142 }); 125 });
143 callback(patterns); 126 callback(patterns);
144 }, 127 },
145 function(selectors) 128 newSelectors =>
146 { 129 {
147 if (!selectors.length) 130 if (!newSelectors.length)
148 return; 131 return;
149 var selector = selectors.join(", "); 132 let selector = newSelectors.join(", ");
150 insertStyleRule(selector + "{display: none !important;}"); 133 insertStyleRule(selector + "{display: none !important;}");
151 }, 134 },
152 function(elements) 135 elems =>
153 { 136 {
154 if (!elements.length) 137 for (let elem of elems)
155 return; 138 elem.style.display = "none";
156 for (var i = 0; i < elements.length; i++)
157 elements[i].style.display = "none";
158 } 139 }
159 ); 140 );
160 141
161 elemHideEmulation.apply(); 142 elemHideEmulation.apply();
162 callback(); 143 return Promise.resolve(elemHideEmulation);
163 }.bind(this));
164 }
165
166 exports.testPseudoHasRule = function(test)
167 {
168 loadElemHideEmulation(function()
169 {
170 var selectors = ["div:has(span)"];
171 // testing the regexp
172 var match = pseudoClassHasSelectorRegExp.exec(selectors[0]);
173 test.ok(match);
174 test.equal(match[1], "span");
175
176 selectors = [":has(div.inside)"];
177 match = pseudoClassHasSelectorRegExp.exec(selectors[0]);
178 test.ok(match);
179 test.equal(match[1], "div.inside");
180
181 test.done();
182 }); 144 });
183 }; 145 }
184 146
185 exports.testExtraFirstSelector = function(test) 147 // internals testing
186 { 148
187 loadElemHideEmulation(function() 149 exports.testParseSelectorContent = function(test)
188 { 150 {
189 var myselector = "elem.class1.class2"; 151 loadElemHideEmulation().then(() =>
190 var shortSel = extractFirstSelector(myselector); 152 {
191 153 let parsed = parseSelectorContent(":-abp-has(> div) > div", 10);
192 test.equal(shortSel, myselector); 154 test.equal(parsed.text, "> div");
193 155 test.equal(parsed.end, 15);
194 myselector = "elem > elem2"; 156
195 shortSel = extractFirstSelector(myselector); 157 parsed = parseSelectorContent("> div) > div", 0);
196 158 test.equal(parsed.text, "> div");
197 test.equal(shortSel, "elem"); 159 test.equal(parsed.end, 5);
198 160
199 myselector = "elem+elem2 > elem3"; 161 // parens not closed.
200 shortSel = extractFirstSelector(myselector); 162 parsed = parseSelectorContent("> div > div", 0);
201 163 test.equal(parsed, null);
202 test.equal(shortSel, "elem"); 164 }).catch(unexpectedError.bind(test)).then(() => test.done());
203 165 };
204 myselector = "elem~elem2 > elem3"; 166
205 shortSel = extractFirstSelector(myselector); 167 exports.testParseSelector = function(test)
206 168 {
207 test.equal(shortSel, "elem"); 169 loadElemHideEmulation().then(() =>
208 170 {
209 test.done(); 171 let selectors = parseSelector("");
210 }); 172 test.equal(selectors.length, 0);
173
174 let selector = "div > :-abp-properties('background-color: rgb(0, 0, 0)')";
175 selectors = parseSelector(selector);
176 test.equal(selectors.length, 2);
177 test.ok(selectors[0] instanceof PlainSelector);
178 test.ok(selectors[1] instanceof PropsSelector);
179
180 selector = "div > :-abp-has(> div.inside) > div";
181 selectors = parseSelector(selector);
182 test.equal(selectors.length, 3);
183 test.ok(selectors[0] instanceof PlainSelector);
184 test.ok(selectors[1] instanceof HasSelector);
185 test.ok(selectors[2] instanceof PlainSelector);
186
187 selector = "div > div:-abp-has(> div.inside) > div";
188 selectors = parseSelector(selector);
189
190 test.equal(selectors.length, 3);
191 test.ok(selectors[0] instanceof PlainSelector);
192 test.ok(selectors[1] instanceof HasSelector);
193 test.ok(selectors[2] instanceof PlainSelector);
194
195 selector = "div > :-abp-has(> div.inside) > :-abp-properties(background-colo r: rgb(0, 0, 0))";
196 selectors = parseSelector(selector);
197
198 test.equal(selectors.length, 4);
199 test.ok(selectors[0] instanceof PlainSelector);
200 test.ok(selectors[1] instanceof HasSelector);
201 test.ok(selectors[2] instanceof PlainSelector);
202 test.ok(selectors[3] instanceof PropsSelector);
203
204 selector = "div > :-abp-has(> div.inside > :-abp-properties(background-color : rgb(0, 0, 0))";
205 selectors = parseSelector(selector);
206 test.equal(selectors, null);
207
208 // -abp-has-unsupported() is unknown. Ensure we fail parsing.
209 selector = 'div[arial-label="Story"]:-abp-has(> div > div > span > span:-abp -unsupported("Suggested Post"))';
210 selectors = parseSelector(selector);
211 test.equal(selectors, null);
212 }).catch(unexpectedError.bind(test)).then(() => test.done());
213 };
214
215 function buildDom(doc)
216 {
217 doc.body.innerHTML = `<div id="parent">
218 <div id="middle">
219 <div id="middle1"><div id="inside" class="inside"></div></div>
220 </div>
221 <div id="sibling">
222 <div id="tohide">to hide</div>
223 </div>
224 <div id="sibling2">
225 <div id="sibling21"><div id="sibling211" class="inside"></div></div>
226 </div>
227 </div>`;
228 let parent = document.getElementById("parent");
229 let middle = document.getElementById("middle");
230 let middle1 = document.getElementById("middle1");
231 let inside = document.getElementById("inside");
232 let sibling = document.getElementById("sibling");
233 let sibling2 = document.getElementById("sibling2");
234 let toHide = document.getElementById("tohide");
235 return {parent, middle, middle1, inside, sibling, sibling2, toHide};
236 }
237
238 exports.testPositionInParent = function(test)
239 {
240 let nodes = buildDom(document);
241
242 loadElemHideEmulation().then(() =>
243 {
244 test.equal(positionInParent(nodes.middle1), 1);
245 test.equal(positionInParent(nodes.inside), 1);
246 test.equal(positionInParent(nodes.sibling2), 3);
247 }).catch(unexpectedError.bind(test)).then(() => test.done());
248 };
249
250 exports.testMakeSelector = function(test)
251 {
252 let nodes = buildDom(document);
253
254 loadElemHideEmulation().then(() =>
255 {
256 test.equal(makeSelector(nodes.middle, ""),
257 ":root > BODY:nth-child(2) > DIV:nth-child(1) > DIV:nth-child(1)" );
258 test.equal(makeSelector(nodes.toHide, ""),
259 ":root > BODY:nth-child(2) > DIV:nth-child(1) > DIV:nth-child(2) > DIV:nth-child(1)");
260 }).catch(unexpectedError.bind(test)).then(() => test.done());
261 };
262
263 exports.testPlainSelector = function(test)
264 {
265 buildDom(document);
266
267 loadElemHideEmulation().then(() =>
268 {
269 let selector = new PlainSelector("div > div");
270
271 let iter = selector.getSelectors("foo > ");
272 let value = iter.next();
273 test.equal(value.value[0], "foo > div > div");
274 test.ok(iter.next().done);
275 }).catch(unexpectedError.bind(test)).then(() => test.done());
276 };
277
278 exports.testHasSelector = function(test)
279 {
280 buildDom(document);
281
282 loadElemHideEmulation().then(() =>
283 {
284 let selector = new HasSelector("> div.inside");
285
286 let iter = selector.getSelectors("", document, document.sheet);
287 let value = iter.next();
288 test.ok(!value.done);
289 test.equal(value.value[0],
290 ":root > BODY:nth-child(2) > DIV:nth-child(1) > DIV:nth-child(1) > DIV:nth-child(1)");
291
292 iter = selector.getElements("", document, document.sheet);
293 value = iter.next();
294 test.ok(!value.done);
295 test.equal(value.value.id, "middle1");
296 value = iter.next();
297 test.ok(!value.done);
298 test.equal(value.value.id, "sibling21");
299 value = iter.next();
300 test.ok(value.done);
301
302 selector = new HasSelector(":-abp-has(> div.inside)");
303
304 test.ok(selector._innerSelectors);
305 }).catch(unexpectedError.bind(test)).then(() => test.done());
211 }; 306 };
212 307
213 exports.testSplitStyleRule = function(test) 308 exports.testSplitStyleRule = function(test)
214 { 309 {
215 loadElemHideEmulation(function() 310 loadElemHideEmulation().then(() =>
216 { 311 {
217 var selectors = splitSelector("div:has(div) > [-abp-properties='background-c olor: rgb(0, 0, 0)'] > span"); 312 let selectors = splitSelector("div:-abp-has(div) > [-abp-properties='backgro und-color: rgb(0, 0, 0)'] > span");
218 test.ok(selectors); 313 test.ok(selectors);
219 test.equal(selectors.length, 1, "There is only one selector"); 314 test.equal(selectors.length, 1, "There is only one selector");
220 315
221 selectors = splitSelector("div:has(div), [-abp-properties='background-color: rgb(0, 0, 0)']"); 316 selectors = splitSelector("div:-abp-has(div), [-abp-properties='background-c olor: rgb(0, 0, 0)']");
222 test.ok(selectors); 317 test.ok(selectors);
223 test.equal(selectors.length, 2, "There are two selectors"); 318 test.equal(selectors.length, 2, "There are two selectors");
224 319 }).catch(unexpectedError.bind(test)).then(() => test.done());
225 test.done(); 320 };
226 }); 321
227 }; 322 // API testing
228 323
229 exports.testVerbatimPropertySelector = function(test) 324 exports.testVerbatimPropertySelector = function(test)
230 { 325 {
231 var toHide = createElementWithStyle("{background-color: #000}"); 326 let toHide = createElementWithStyle("{background-color: #000}");
232 applyElemHideEmulation( 327 applyElemHideEmulation(
233 ["[-abp-properties='background-color: rgb(0, 0, 0)']"], 328 [":-abp-properties(background-color: rgb(0, 0, 0))"]
234 function() 329 ).then(() =>
330 {
331 expectHidden(test, toHide);
332 }).catch(unexpectedError.bind(test)).then(() => test.done());
333 };
334
335 exports.testVerbatimPropertySelectorWithPrefix = function(test)
336 {
337 let parent = createElementWithStyle("{background-color: #000}");
338 let toHide = createElementWithStyle("{background-color: #000}", parent);
339 applyElemHideEmulation(
340 ["div > :-abp-properties(background-color: rgb(0, 0, 0))"]
341 ).then(() =>
342 {
343 expectVisible(test, parent);
344 expectHidden(test, toHide);
345 }).catch(unexpectedError.bind(test)).then(() => test.done());
346 };
347
348 exports.testVerbatimPropertySelectorWithPrefixNoMatch = function(test)
349 {
350 let parent = createElementWithStyle("{background-color: #000}");
351 let toHide = createElementWithStyle("{background-color: #fff}", parent);
352 applyElemHideEmulation(
353 ["div > :-abp-properties(background-color: rgb(0, 0, 0))"]
354 ).then(() =>
355 {
356 expectVisible(test, parent);
357 expectVisible(test, toHide);
358 }).catch(unexpectedError.bind(test)).then(() => test.done());
359 };
360
361 exports.testVerbatimPropertySelectorWithSuffix = function(test)
362 {
363 let parent = createElementWithStyle("{background-color: #000}");
364 let toHide = createElementWithStyle("{background-color: #000}", parent);
365 applyElemHideEmulation(
366 [":-abp-properties(background-color: rgb(0, 0, 0)) > div"]
367 ).then(() =>
368 {
369 expectVisible(test, parent);
370 expectHidden(test, toHide);
371 }).catch(unexpectedError.bind(test)).then(() => test.done());
372 };
373
374 exports.testVerbatimPropertyPseudoSelectorWithPrefixAndSuffix = function(test)
375 {
376 let parent = createElementWithStyle("{background-color: #000}");
377 let middle = createElementWithStyle("{background-color: #000}", parent);
378 let toHide = createElementWithStyle("{background-color: #000}", middle);
379 applyElemHideEmulation(
380 ["div > :-abp-properties(background-color: rgb(0, 0, 0)) > div"]
381 ).then(() =>
382 {
383 expectVisible(test, parent);
384 expectVisible(test, middle);
385 expectHidden(test, toHide);
386 }).catch(unexpectedError.bind(test)).then(() => test.done());
387 };
388
389 exports.testPropertySelectorWithWildcard = function(test)
390 {
391 let toHide = createElementWithStyle("{background-color: #000}");
392 applyElemHideEmulation(
393 [":-abp-properties(*color: rgb(0, 0, 0))"]
394 ).then(() =>
395 {
396 expectHidden(test, toHide);
397 }).catch(unexpectedError.bind(test)).then(() => test.done());
398 };
399
400 exports.testPropertySelectorWithRegularExpression = function(test)
401 {
402 let toHide = createElementWithStyle("{background-color: #000}");
403 applyElemHideEmulation(
404 [":-abp-properties(/.*color: rgb\\(0, 0, 0\\)/)"]
405 ).then(() =>
406 {
407 expectHidden(test, toHide);
408 }).catch(unexpectedError.bind(test)).then(() => test.done());
409 };
410
411 exports.testPropertySelectorWithEscapedBrace = function(test)
412 {
413 let toHide = createElementWithStyle("{background-color: #000}");
414 applyElemHideEmulation(
415 [":-abp-properties(/background.\\x7B 0,6\\x7D : rgb\\(0, 0, 0\\)/)"]
416 ).then(() =>
417 {
418 expectHidden(test, toHide);
419 }).catch(unexpectedError.bind(test)).then(() => test.done());
420 };
421
422 exports.testPropertySelectorWithImproperlyEscapedBrace = function(test)
423 {
424 let toHide = createElementWithStyle("{background-color: #000}");
425 applyElemHideEmulation(
426 [":-abp-properties(/background.\\x7B0,6\\x7D: rgb\\(0, 0, 0\\)/)"]
427 ).then(() =>
428 {
429 expectVisible(test, toHide);
430 }).catch(unexpectedError.bind(test)).then(() => test.done());
431 };
432
433 exports.testDynamicallyChangedProperty = function(test)
434 {
435 let toHide = createElementWithStyle("{}");
436 applyElemHideEmulation(
437 [":-abp-properties(background-color: rgb(0, 0, 0))"]
438 ).then(() =>
439 {
440 expectVisible(test, toHide);
441 insertStyleRule("#" + toHide.id + " {background-color: #000}");
442 return new Promise((resolve, reject) =>
235 { 443 {
236 expectHidden(test, toHide); 444 window.setTimeout(() =>
237 test.done();
238 }
239 );
240 };
241
242 exports.testVerbatimPropertySelectorWithPrefix = function(test)
243 {
244 var parent = createElementWithStyle("{background-color: #000}");
245 var toHide = createElementWithStyle("{background-color: #000}", parent);
246 applyElemHideEmulation(
247 ["div > [-abp-properties='background-color: rgb(0, 0, 0)']"],
248 function()
249 {
250 expectVisible(test, parent);
251 expectHidden(test, toHide);
252 test.done();
253 }
254 );
255 };
256
257 exports.testVerbatimPropertySelectorWithPrefixNoMatch = function(test)
258 {
259 var parent = createElementWithStyle("{background-color: #000}");
260 var toHide = createElementWithStyle("{background-color: #fff}", parent);
261 applyElemHideEmulation(
262 ["div > [-abp-properties='background-color: rgb(0, 0, 0)']"],
263 function()
264 {
265 expectVisible(test, parent);
266 expectVisible(test, toHide);
267 test.done();
268 }
269 );
270 };
271
272 exports.testVerbatimPropertySelectorWithSuffix = function(test)
273 {
274 var parent = createElementWithStyle("{background-color: #000}");
275 var toHide = createElementWithStyle("{background-color: #000}", parent);
276 applyElemHideEmulation(
277 ["[-abp-properties='background-color: rgb(0, 0, 0)'] > div"],
278 function()
279 {
280 expectVisible(test, parent);
281 expectHidden(test, toHide);
282 test.done();
283 }
284 );
285 };
286
287 exports.testVerbatimPropertySelectorWithPrefixAndSuffix = function(test)
288 {
289 var parent = createElementWithStyle("{background-color: #000}");
290 var middle = createElementWithStyle("{background-color: #000}", parent);
291 var toHide = createElementWithStyle("{background-color: #000}", middle);
292 applyElemHideEmulation(
293 ["div > [-abp-properties='background-color: rgb(0, 0, 0)'] > div"],
294 function()
295 {
296 expectVisible(test, parent);
297 expectVisible(test, middle);
298 expectHidden(test, toHide);
299 test.done();
300 }
301 );
302 };
303
304 exports.testPropertySelectorWithWildcard = function(test)
305 {
306 var toHide = createElementWithStyle("{background-color: #000}");
307 applyElemHideEmulation(
308 ["[-abp-properties='*color: rgb(0, 0, 0)']"],
309 function()
310 {
311 expectHidden(test, toHide);
312 test.done();
313 }
314 );
315 };
316
317 exports.testPropertySelectorWithRegularExpression = function(test)
318 {
319 var toHide = createElementWithStyle("{background-color: #000}");
320 applyElemHideEmulation(
321 ["[-abp-properties='/.*color: rgb\\(0, 0, 0\\)/']"],
322 function()
323 {
324 expectHidden(test, toHide);
325 test.done();
326 }
327 );
328 };
329
330 exports.testPropertySelectorWithEscapedBrace = function(test)
331 {
332 var toHide = createElementWithStyle("{background-color: #000}");
333 applyElemHideEmulation(
334 ["[-abp-properties='/background.\\x7B 0,6\\x7D : rgb\\(0, 0, 0\\)/']"],
335 function()
336 {
337 expectHidden(test, toHide);
338 test.done();
339 }
340 );
341 };
342
343 exports.testPropertySelectorWithImproperlyEscapedBrace = function(test)
344 {
345 var toHide = createElementWithStyle("{background-color: #000}");
346 applyElemHideEmulation(
347 ["[-abp-properties='/background.\\x7B0,6\\x7D: rgb\\(0, 0, 0\\)/']"],
348 function()
349 {
350 expectVisible(test, toHide);
351 test.done();
352 }
353 );
354 };
355
356 exports.testDynamicallyChangedProperty = function(test)
357 {
358 var toHide = createElementWithStyle("{}");
359 applyElemHideEmulation(
360 ["[-abp-properties='background-color: rgb(0, 0, 0)']"],
361 function()
362 {
363 expectVisible(test, toHide);
364 insertStyleRule("#" + toHide.id + " {background-color: #000}");
365 window.setTimeout(function()
366 { 445 {
367 expectHidden(test, toHide); 446 expectHidden(test, toHide);
368 test.done(); 447 resolve();
369 }, 0); 448 }, 0);
370 } 449 });
371 ); 450 }).catch(unexpectedError.bind(test)).then(() => test.done());
372 };
373
374 exports.testPseudoClassHasMatcher = function(test)
375 {
376 var parent = createElementWithStyle("{}");
377 var child = createElementWithStyle("{}", parent);
378 loadElemHideEmulation(function()
379 {
380 var matcher = new PseudoHasMatcher("div");
381 test.equal(matcher.match(parent).length, 1, "Parent should contain what is e xpected");
382 test.equal(matcher.match(child).length, 0, "Child shouldn't match");
383
384 var matcher2 = new PseudoHasMatcher("span");
385 test.equal(matcher2.match(parent), 0, "Doesn't have a <span> child, shouldn' t mactch");
386 test.equal(matcher2.match(child), 0, "Child shouldn't match");
387
388 test.done();
389 });
390 }; 451 };
391 452
392 exports.testPseudoClassHasSelector = function(test) 453 exports.testPseudoClassHasSelector = function(test)
393 { 454 {
394 var toHide = createElementWithStyle("{}"); 455 let toHide = createElementWithStyle("{}");
395 applyElemHideEmulation( 456 applyElemHideEmulation(
396 ["div:has(div)"], 457 ["div:-abp-has(div)"]
397 function() 458 ).then(() =>
398 { 459 {
399 expectVisible(test, toHide); 460 expectVisible(test, toHide);
400 test.done(); 461 }).catch(unexpectedError.bind(test)).then(() => test.done());
401 }
402 );
403 }; 462 };
404 463
405 exports.testPseudoClassHasSelectorWithPrefix = function(test) 464 exports.testPseudoClassHasSelectorWithPrefix = function(test)
406 { 465 {
407 var parent = createElementWithStyle("{}"); 466 let parent = createElementWithStyle("{}");
408 var child = createElementWithStyle("{}", parent); 467 let child = createElementWithStyle("{}", parent);
409 applyElemHideEmulation( 468 applyElemHideEmulation(
410 ["div:has(div)"], 469 ["div:-abp-has(div)"]
411 function() 470 ).then(() =>
412 { 471 {
413 expectHidden(test, parent); 472 expectHidden(test, parent);
414 expectVisible(test, child); 473 expectVisible(test, child);
415 test.done(); 474 }).catch(unexpectedError.bind(test)).then(() => test.done());
416 }
417 );
418 }; 475 };
419 476
420 exports.testPseudoClassHasSelectorWithSuffix = function(test) 477 exports.testPseudoClassHasSelectorWithSuffix = function(test)
421 { 478 {
422 var parent = createElementWithStyle("{}"); 479 let parent = createElementWithStyle("{}");
423 var middle = createElementWithStyle("{}", parent); 480 let middle = createElementWithStyle("{}", parent);
424 var child = createElementWithStyle("{}", middle); 481 let child = createElementWithStyle("{}", middle);
425 applyElemHideEmulation( 482 applyElemHideEmulation(
426 ["div:has(div) > div"], 483 ["div:-abp-has(div) > div"]
427 function() 484 ).then(() =>
428 { 485 {
429 expectVisible(test, parent); 486 expectVisible(test, parent);
430 expectVisible(test, middle); 487 expectHidden(test, middle);
431 expectHidden(test, child); 488 expectHidden(test, child);
432 test.done(); 489 }).catch(unexpectedError.bind(test)).then(() => test.done());
433 }
434 );
435 }; 490 };
436 491
437 exports.testPseudoClassHasSelectorWithSuffixSibling = function(test) 492 exports.testPseudoClassHasSelectorWithSuffixSibling = function(test)
438 { 493 {
439 var parent = createElementWithStyle("{}"); 494 let parent = createElementWithStyle("{}");
440 var middle = createElementWithStyle("{}", parent); 495 let middle = createElementWithStyle("{}", parent);
441 var toHide = createElementWithStyle("{}", parent); 496 let toHide = createElementWithStyle("{}");
442 applyElemHideEmulation( 497 applyElemHideEmulation(
443 ["div:has(div) + div"], 498 ["div:-abp-has(div) + div"]
444 function() 499 ).then(() =>
445 { 500 {
446 expectVisible(test, parent); 501 expectVisible(test, parent);
447 expectVisible(test, middle); 502 expectVisible(test, middle);
448 expectHidden(test, toHide); 503 expectHidden(test, toHide);
449 test.done(); 504 }).catch(unexpectedError.bind(test)).then(() => test.done());
450 } 505 };
451 ); 506
452 }; 507 exports.testPseudoClassHasSelectorWithSuffixSiblingChild = function(test)
453
454 exports.testPseudoClassHasSelectorWithSuffixSibling = function(test)
455 { 508 {
456 // <div> 509 // <div>
457 // <div></div> 510 // <div></div>
458 // <div> 511 // <div>
459 // <div>to hide</div> 512 // <div>to hide</div>
460 // </div> 513 // </div>
461 // </div> 514 // </div>
462 var parent = createElementWithStyle("{}"); 515 let parent = createElementWithStyle("{}");
463 var middle = createElementWithStyle("{}", parent); 516 let middle = createElementWithStyle("{}", parent);
464 var sibling = createElementWithStyle("{}", parent); 517 let sibling = createElementWithStyle("{}");
465 var toHide = createElementWithStyle("{}", sibling); 518 let toHide = createElementWithStyle("{}", sibling);
466 applyElemHideEmulation( 519 applyElemHideEmulation(
467 ["div:has(div) + div > div"], 520 ["div:-abp-has(div) + div > div"]
468 function() 521 ).then(() =>
469 { 522 {
470 expectVisible(test, parent); 523 expectVisible(test, parent);
471 expectVisible(test, middle); 524 expectVisible(test, middle);
472 expectVisible(test, sibling); 525 expectVisible(test, sibling);
473 expectHidden(test, toHide); 526 expectHidden(test, toHide);
474 test.done(); 527 }).catch(unexpectedError.bind(test)).then(() => test.done());
475 } 528 };
476 ); 529
477 }; 530 function runTestPseudoClassHasSelectorWithHasAndWithSuffixSibling(test, selector )
531 {
532 document.body.innerHTML = `<div id="parent">
533 <div id="middle">
534 <div id="middle1"><div id="inside" class="inside"></div></div>
535 </div>
536 <div id="sibling">
537 <div id="tohide">to hide</div>
538 </div>
539 <div id="sibling2">
540 <div id="sibling21"><div id="sibling211" class="inside"></div></div>
541 </div>
542 </div>`;
543 let parent = document.getElementById("parent");
544 let middle = document.getElementById("middle");
545 let inside = document.getElementById("inside");
546 let sibling = document.getElementById("sibling");
547 let sibling2 = document.getElementById("sibling2");
548 let toHide = document.getElementById("tohide");
549
550 insertStyleRule(".inside {}");
551
552 applyElemHideEmulation(
553 [selector]
554 ).then(() =>
555 {
556 expectVisible(test, parent);
557 expectVisible(test, middle);
558 expectVisible(test, inside);
559 expectVisible(test, sibling);
560 expectVisible(test, sibling2);
561 expectHidden(test, toHide);
562 }).catch(unexpectedError.bind(test)).then(() => test.done());
563 }
478 564
479 exports.testPseudoClassHasSelectorWithHasAndWithSuffixSibling = function(test) 565 exports.testPseudoClassHasSelectorWithHasAndWithSuffixSibling = function(test)
480 { 566 {
481 // <div> 567 runTestPseudoClassHasSelectorWithHasAndWithSuffixSibling(test, "div:-abp-has(: -abp-has(div.inside)) + div > div");
482 // <div><div class="inside"></div></div> 568 };
483 // <div> 569
484 // <div>to hide</div> 570 exports.testPseudoClassHasSelectorWithHasAndWithSuffixSibling2 = function(test)
485 // </div> 571 {
486 // </div> 572 runTestPseudoClassHasSelectorWithHasAndWithSuffixSibling(test, "div:-abp-has(: -abp-has(> div.inside)) + div > div");
487 var parent = createElementWithStyle("{}"); 573 };
488 var middle = createElementWithStyle("{}", parent);
489 var inside = createElementWithStyle("{}", middle);
490 inside.className = "inside";
491 var sibling = createElementWithStyle("{}", parent);
492 var toHide = createElementWithStyle("{}", sibling);
493 applyElemHideEmulation(
494 ["div:has(:has(div.inside)) + div > div"],
495 function()
496 {
497 expectVisible(test, parent);
498 expectVisible(test, middle);
499 expectVisible(test, inside);
500 expectVisible(test, sibling);
501 expectHidden(test, toHide);
502 test.done();
503 }
504 );
505 };
506
507 574
508 exports.testPseudoClassHasSelectorWithPropSelector = function(test) 575 exports.testPseudoClassHasSelectorWithPropSelector = function(test)
509 { 576 {
510 var parent = createElementWithStyle("{}"); 577 let parent = createElementWithStyle("{}");
511 var child = createElementWithStyle("{background-color: #000}", parent); 578 let child = createElementWithStyle("{background-color: #000}", parent);
512 applyElemHideEmulation( 579 applyElemHideEmulation(
513 ["div:has([-abp-properties='background-color: rgb(0, 0, 0)'])"], 580 ["div:-abp-has(:-abp-properties(background-color: rgb(0, 0, 0)))"]
514 function() 581 ).then(() =>
515 { 582 {
516 expectVisible(test, child); 583 expectVisible(test, child);
517 expectHidden(test, parent); 584 expectHidden(test, parent);
518 test.done(); 585 }).catch(unexpectedError.bind(test)).then(() => test.done());
519 } 586 };
520 );
521 };
LEFTRIGHT

Powered by Google App Engine
This is Rietveld