Debian Codegraph @

plugins/css-has-pseudo/test/_browser.html

raw
1 <!DOCTYPE html>
2 <html lang="en">
3 <head>
4 <meta charset="utf-8">
5 <title></title>
6 <link rel="help" href="https://drafts.csswg.org/selectors/#relational">
7 <!-- Included only to trigger CORS errors -->
8 <!-- This stylesheet is not accessible in JS and must not cause cascading failures -->
9 <link rel="stylesheet" href="http://localhost:8081/test/basic.expect.css">
10 <!-- This is the real test stylesheet and has correct CORS attributes and http headers -->
11 <link rel="stylesheet" href="http://localhost:8081/test/browser.expect.css" crossorigin="anonymous">
12 <script src="http://localhost:8082/dist/browser-global.js"></script>
13 <script>cssHasPseudo(document, { observedAttributes: ['attrname', 'a_test_attr', 'c_test_attr'], debug: false, hover: true, forcePolyfill: window.location.hash === '#force-polyfill' });</script>
14 </head>
15 <body>
16 <the-fixture id="fixture"></the-fixture>
17
18 <script type="module">
19 function rafP(callback) {
20 return new Promise((resolve) => {
21 requestAnimationFrame(() => {
22 requestAnimationFrame(() => {
23 callback();
24 resolve();
25 });
26 });
27 });
28 }
29
30 self.runTest = async function runTest() {
31 const adjacentPositionResult = await testAdjacentPosition();
32 const hasWithPseudoClassesResult = await testHasWithPseudoClasses();
33 const invalidationResult = await testInvalidation();
34 const nestedResult = await testNestedHas();
35 const parentPositionResult = await testParentPosition();
36 const pseudoResult = await testPseudos();
37 const specificityResult = await testSpecificity();
38 const visitednessResult = await testVisitedness();
39
40 return (
41 adjacentPositionResult &&
42 hasWithPseudoClassesResult &&
43 invalidationResult &&
44 nestedResult &&
45 parentPositionResult &&
46 pseudoResult &&
47 specificityResult &&
48 visitednessResult
49 );
50 }
51
52 async function testHasWithPseudoClasses() {
53 // https://github.com/web-platform-tests/wpt/blob/master/css/selectors/invalidation/has-pseudo-class.html
54
55 fixture.innerHTML = `
56 <main id="d_main">
57 <input type="checkbox" id="d_checkbox"></input>
58 <select id="d_select">
59 <optgroup id="d_optgroup">
60 <option>a</option>
61 <option id="d_option">b</option>
62 </optgroup>
63 </select>
64 <div id="d_subject"></div>
65 <div id="d_subject2"></div>
66 <div id="d_subject3"></div>
67 <div id="d_subject4"></div>
68 </main>
69 `;
70
71 const grey = 'rgb(128, 128, 128)';
72 const red = 'rgb(255, 0, 0)';
73 const green = 'rgb(0, 128, 0)';
74 const blue = 'rgb(0, 0, 255)';
75
76 function testColor(test_name, el, color) {
77 var actual = getComputedStyle(el).color;
78 if (actual !== color) {
79 throw new Error(test_name + ': div#' + el.id + '.color; expected ' + color + ' but got ' + actual);
80 }
81 }
82
83 async function testPseudoClassChange(element, property, subject_element, expectedColor) {
84 await rafP(() => {
85 testColor(`Before set ${property} on ${element.id}, testing ${subject_element.id}`, subject_element, grey);
86 });
87
88 element[property] = true;
89
90 await rafP(() => {
91 testColor(`Set ${property} on ${element.id}, testing ${subject_element.id}`, subject_element, expectedColor);
92 });
93
94 element[property] = false;
95
96 await rafP(() => {
97 testColor(`Unset ${property} on ${element.id}, testing ${subject_element.id}`, subject_element, grey);
98 });
99 }
100
101 async function testSelectedChange(option, subject_element, expectedColor) {
102 const oldOption = d_select.selectedOptions[0];
103
104 option.selected = true;
105
106 await rafP(() => {
107 testColor(`Set select on ${option.id}`, subject_element, expectedColor);
108 });
109
110 oldOption.selected = true;
111
112 await rafP(() => {
113 testColor(`Reset select`, d_subject, grey);
114 });
115 }
116
117 await testPseudoClassChange(d_checkbox, "checked", d_subject, red);
118 await testSelectedChange(d_option, d_subject, red);
119
120 await testPseudoClassChange(d_checkbox, "disabled", d_subject, green);
121 await testPseudoClassChange(d_checkbox, "disabled", d_subject3, green);
122 await testPseudoClassChange(d_option, "disabled", d_subject, green);
123 await testPseudoClassChange(d_option, "disabled", d_subject3, green);
124
125 await testPseudoClassChange(d_optgroup, "disabled", d_subject, blue);
126 await testPseudoClassChange(d_optgroup, "disabled", d_subject2, green);
127 await testPseudoClassChange(d_optgroup, "disabled", d_subject3, blue);
128 await testPseudoClassChange(d_optgroup, "disabled", d_subject4, green);
129
130 return true;
131 }
132
133 async function testVisitedness() {
134 // https://github.com/web-platform-tests/wpt/blob/master/css/selectors/has-visited.html
135
136 fixture.innerHTML = `
137 <div id="visited-1">
138 <div>parent color should be green with <a href="">visited link</a>.</div>
139 </div>
140 <div id="visited-2">
141 <div>parent color should be black with <a href="unvisited">unvisited link</a>.</div>
142 </div>
143 <div id="visited-3">
144 <div>parent color should be yellowgreen with <a href="unvisited">any link</a>.</div>
145 </div>
146 <div id="visited-4">
147 <div>parent color should be black with <a href="">visited link</a>.</div>
148 </div>
149 `;
150
151 const black = 'rgb(0, 0, 0)';
152 const green = 'rgb(0, 128, 0)';
153 const yellow_green = 'rgb(154, 205, 50)';
154
155 function testColor(el, color) {
156 var actual = getComputedStyle(el).color;
157 if (actual !== color) {
158 throw new Error('div#' + el.id + '.color; expected ' + color + ' but got ' + actual);
159 }
160 }
161
162 await rafP(() => {
163 testColor(document.getElementById('visited-1'), green);
164 testColor(document.getElementById('visited-2'), black);
165 testColor(document.getElementById('visited-3'), yellow_green);
166 testColor(document.getElementById('visited-4'), black);
167 });
168
169 return true;
170 }
171
172 async function testSpecificity() {
173 // https://github.com/web-platform-tests/wpt/blob/2b811aa5c2/css/selectors/has-specificity.html
174
175 fixture.innerHTML = `
176 <main id="main_specificity">
177 <div id=div><p><span id=foo class=foo></span><span class=bar></span><li></li></p></div>
178 </main>
179 `;
180
181 function test_value(name, description) {
182 let actual = getComputedStyle(div).getPropertyValue(name);
183 if (actual !== 'PASS') {
184 throw new Error(`${name}: expected "PASS", got "${actual}"`);
185 }
186 }
187
188 await rafP(() => {
189 test_value('--t0', ':has(#foo) wins over :has(.foo)');
190 test_value('--t1', ':has(span#foo) wins over :has(#foo)');
191 test_value('--t2', ':has(.bar, #foo) has same specificity as :has(#foo, .bar)');
192 test_value('--t3', ':has(.bar, #foo) wins over :has(.foo, .bar)');
193 test_value('--t4', ':has(span + span) wins over :has(span)');
194 test_value('--t5', ':has(span, li, p) wins over :has(span, lo, p)');
195 });
196
197 return true;
198 }
199
200 async function testParentPosition() {
201 // https://github.com/web-platform-tests/wpt/blob/master/css/selectors/invalidation/has-in-ancestor-position.html
202
203 fixture.innerHTML = `
204 <main id="c_main">
205 <div id="c_subject_ancestor">
206 <div id="c_subject_parent">
207 <div id="c_subject">
208 <div id="c_subject_child">
209 <div id="c_subject_descendant"></div>
210 </div>
211 </div>
212 </div>
213 </div>
214 <div id="c_next_sibling">
215 <div id="c_next_sibling_child">
216 <div id="c_next_sibling_descendant"></div>
217 </div>
218 </div>
219 </main>
220 `;
221
222 const grey = 'rgb(128, 128, 128)';
223 const red = 'rgb(255, 0, 0)';
224 const green = 'rgb(0, 128, 0)';
225 const blue = 'rgb(0, 0, 255)';
226 const yellow = 'rgb(255, 255, 0)';
227 const purple = 'rgb(128, 0, 128)';
228 const pink = 'rgb(255, 192, 203)';
229
230 function testColor(test_name, color) {
231 var actual = getComputedStyle(c_subject).backgroundColor;
232 if (actual !== color) {
233 throw new Error(test_name + ': expected ' + color + ' but got ' + actual);
234 }
235 }
236
237 async function testClassChange(element, expectedColor) {
238 element.classList.add('c_test');
239 await rafP(() => {
240 testColor(`add .c_test to ${element.id}`, expectedColor);
241 });
242 element.classList.remove('c_test');
243 await rafP(() => {
244 testColor(`remove .c_test from ${element.id}`, grey);
245 });
246 }
247
248 async function testElementInsertionBefore(beforeElement, expectedColor) {
249 const newElement = document.createElement('div');
250 newElement.classList.add('c_test');
251
252 beforeElement.before(newElement);
253 await rafP(() => {
254 testColor(`insert element div.test before ${beforeElement.id}`, expectedColor);
255 });
256
257 newElement.classList.remove('c_test');
258 await rafP(() => {
259 testColor(`remove the class 'test' from the element inserted before ${beforeElement.id}`, grey);
260 });
261
262 newElement.classList.add('c_test');
263 await rafP(() => {
264 testColor(`add the class 'test' again to the element inserted before ${beforeElement.id}`, expectedColor);
265 });
266
267 newElement.remove();
268 await rafP(() => {
269 testColor(`remove element div.test before ${beforeElement.id}`, grey);
270 });
271
272 newElement.classList.remove('c_test');
273
274 beforeElement.before(newElement);
275 await rafP(() => {
276 testColor(`insert element div before ${beforeElement.id}`, grey);
277 });
278
279 newElement.classList.add('c_test');
280 await rafP(() => {
281 testColor(`add the class 'test' to the element inserted again before ${beforeElement.id}`, expectedColor);
282 });
283
284 newElement.classList.remove('c_test');
285 await rafP(() => {
286 testColor(`remove the class 'test' from the element inserted again before ${beforeElement.id}`, grey);
287 });
288
289 newElement.remove();
290 await rafP(() => {
291 testColor(`remove element div before ${beforeElement.id}`, grey);
292 });
293
294 newElement.setAttribute('c_test_attr', '');
295
296 beforeElement.before(newElement);
297 await rafP(() => {
298 testColor(`insert element div[test_attr] before ${beforeElement.id}`, expectedColor);
299 });
300
301 newElement.removeAttribute('c_test_attr');
302 await rafP(() => {
303 testColor(`remove attribute div[test_attr] before ${beforeElement.id}`, grey);
304 });
305
306 newElement.setAttribute('c_test_attr', '');
307 await rafP(() => {
308 testColor(`insert attribute div[test_attr] before ${beforeElement.id}`, expectedColor);
309 });
310
311 newElement.remove();
312 await rafP(() => {
313 testColor(`remove element div[test_attr] before ${beforeElement.id}`, grey);
314 });
315 }
316
317 async function testElementInsertionAfter(afterElement, expectedColor) {
318 const newElement = document.createElement('div');
319 newElement.classList.add('c_test');
320
321 afterElement.after(newElement);
322 await rafP(() => {
323 testColor(`insert element div.test after ${afterElement.id}`, expectedColor);
324 });
325
326 newElement.classList.remove('c_test');
327 await rafP(() => {
328 testColor(`remove the class 'test' from the element inserted after ${afterElement.id}`, grey);
329 });
330
331 newElement.classList.add('c_test');
332 await rafP(() => {
333 testColor(`add the class 'test' again to the element inserted after ${afterElement.id}`, expectedColor);
334 });
335
336 newElement.remove();
337 await rafP(() => {
338 testColor(`remove element div.test after ${afterElement.id}`, grey);
339 });
340
341 newElement.classList.remove('c_test');
342
343 afterElement.after(newElement);
344 await rafP(() => {
345 testColor(`insert element div after ${afterElement.id}`, grey);
346 });
347
348 newElement.classList.add('c_test');
349 await rafP(() => {
350 testColor(`add the class 'test' to the element inserted again after ${afterElement.id}`, expectedColor);
351 });
352
353 newElement.classList.remove('c_test');
354 await rafP(() => {
355 testColor(`remove the class 'test' from the element inserted again after ${afterElement.id}`, grey);
356 });
357
358 newElement.remove();
359 await rafP(() => {
360 testColor(`remove element div after ${afterElement.id}`, grey);
361 });
362
363 newElement.setAttribute('c_test_attr', '');
364
365 afterElement.after(newElement);
366 await rafP(() => {
367 testColor(`insert element div[c_test_attr] after ${afterElement.id}`, expectedColor);
368 });
369
370 newElement.removeAttribute('c_test_attr');
371 await rafP(() => {
372 testColor(`remove attribute div[test_attr] before ${afterElement.id}`, grey);
373 });
374
375 newElement.setAttribute('c_test_attr', '');
376 await rafP(() => {
377 testColor(`insert attribute div[test_attr] before ${afterElement.id}`, expectedColor);
378 });
379
380 newElement.remove();
381 await rafP(() => {
382 testColor(`remove element div[c_test_attr] after ${afterElement.id}`, grey);
383 });
384 }
385
386 async function testTreeInsertionBefore(beforeElement, expectedColor) {
387 const newElement = document.createElement('div');
388 const newChild = document.createElement('div');
389 newChild.classList.add('c_test');
390 newElement.appendChild(newChild);
391
392 beforeElement.before(newElement);
393 await rafP(() => {
394 testColor(`insert tree div>div.test before ${beforeElement.id}`, expectedColor);
395 });
396
397 newChild.classList.remove('c_test');
398 await rafP(() => {
399 testColor(`remove the class 'test' from the element in the tree inserted before ${beforeElement.id}`, grey);
400 });
401
402 newChild.classList.add('c_test');
403 await rafP(() => {
404 testColor(`add the class 'test' again to the element in the tree inserted before ${beforeElement.id}`, expectedColor);
405 });
406
407 newElement.remove();
408 await rafP(() => {
409 testColor(`remove tree div>div.test before ${beforeElement.id}`, grey);
410 });
411
412 newChild.classList.remove('c_test');
413
414 beforeElement.before(newElement);
415 await rafP(() => {
416 testColor(`insert tree div>div before ${beforeElement.id}`, grey);
417 });
418
419 newChild.classList.add('c_test');
420 await rafP(() => {
421 testColor(`add the class 'test' to the element in the tree inserted again before ${beforeElement.id}`, expectedColor);
422 });
423
424 newChild.classList.remove('c_test');
425 await rafP(() => {
426 testColor(`remove the class 'test' from the element in the tree inserted again before ${beforeElement.id}`, grey);
427 });
428
429 newElement.remove();
430 await rafP(() => {
431 testColor(`remove tree div>div before ${beforeElement.id}`, grey);
432 });
433
434 newChild.setAttribute('c_test_attr', '');
435
436 beforeElement.before(newElement);
437 await rafP(() => {
438 testColor(`insert element div>div[test_attr] before ${beforeElement.id}`, expectedColor);
439 });
440
441 newChild.removeAttribute('c_test_attr');
442 await rafP(() => {
443 testColor(`remove attribute div[test_attr] before ${beforeElement.id}`, grey);
444 });
445
446 newChild.setAttribute('c_test_attr', '');
447 await rafP(() => {
448 testColor(`insert attribute div[test_attr] before ${beforeElement.id}`, expectedColor);
449 });
450
451 newElement.remove();
452 await rafP(() => {
453 testColor(`remove element div>div[test_attr] before ${beforeElement.id}`, grey);
454 });
455 }
456
457 async function testTreeInsertionAfter(afterElement, expectedColor) {
458 const newElement = document.createElement('div');
459 const newChild = document.createElement('div');
460 newChild.classList.add('c_test');
461 newElement.appendChild(newChild);
462
463 afterElement.after(newElement);
464 await rafP(() => {
465 testColor(`insert tree div>div.test after ${afterElement.id}`, expectedColor);
466 });
467
468 newChild.classList.remove('c_test');
469 await rafP(() => {
470 testColor(`remove the class 'test' from the element in the tree inserted after ${afterElement.id}`, grey);
471 });
472
473 newChild.classList.add('c_test');
474 await rafP(() => {
475 testColor(`add the class 'test' again to the element in the tree inserted after ${afterElement.id}`, expectedColor);
476 });
477
478 newElement.remove();
479 await rafP(() => {
480 testColor(`remove tree div>div.test after ${afterElement.id}`, grey);
481 });
482
483 newChild.classList.remove('c_test');
484
485 afterElement.after(newElement);
486 await rafP(() => {
487 testColor(`insert tree div>div after ${afterElement.id}`, grey);
488 });
489
490 newChild.classList.add('c_test');
491 await rafP(() => {
492 testColor(`add the class 'test' to the element in the tree inserted again after ${afterElement.id}`, expectedColor);
493 });
494
495 newChild.classList.remove('c_test');
496 await rafP(() => {
497 testColor(`remove the class 'test' from the element in the tree inserted again after ${afterElement.id}`, grey);
498 });
499
500 newElement.remove();
501 await rafP(() => {
502 testColor(`remove tree div>div after ${afterElement.id}`, grey);
503 });
504
505 newChild.setAttribute('c_test_attr', '');
506
507 afterElement.after(newElement);
508 await rafP(() => {
509 testColor(`insert element div>div[test_attr] after ${afterElement.id}`, expectedColor);
510 });
511
512 newChild.removeAttribute('c_test_attr');
513 await rafP(() => {
514 testColor(`remove attribute div[test_attr] before ${afterElement.id}`, grey);
515 });
516
517 newChild.setAttribute('c_test_attr', '');
518 await rafP(() => {
519 testColor(`insert attribute div[test_attr] before ${afterElement.id}`, expectedColor);
520 });
521
522 newElement.remove();
523 await rafP(() => {
524 testColor(`remove element div>div[test_attr] after ${afterElement.id}`, grey);
525 });
526 }
527
528 await testColor('Initial color', grey);
529
530 await testClassChange(c_subject_ancestor, grey);
531 await testClassChange(c_subject_parent, green);
532 await testClassChange(c_subject, green);
533 await testClassChange(c_subject_child, red);
534 await testClassChange(c_subject_descendant, red);
535 await testClassChange(c_next_sibling, blue);
536 await testClassChange(c_next_sibling_child, pink);
537 await testClassChange(c_next_sibling_descendant, pink);
538
539 await testElementInsertionBefore(c_subject_ancestor, grey);
540 await testElementInsertionBefore(c_subject_parent, green);
541 await testElementInsertionBefore(c_subject, green);
542 await testElementInsertionBefore(c_subject_child, red);
543 await testElementInsertionBefore(c_subject_descendant, red);
544 await testElementInsertionBefore(c_next_sibling, blue);
545 await testElementInsertionBefore(c_next_sibling_child, pink);
546 await testElementInsertionBefore(c_next_sibling_descendant, pink);
547
548 await testElementInsertionAfter(c_subject_ancestor, blue);
549 await testElementInsertionAfter(c_subject_parent, blue);
550 await testElementInsertionAfter(c_subject, green);
551 await testElementInsertionAfter(c_subject_child, red);
552 await testElementInsertionAfter(c_subject_descendant, red);
553 await testElementInsertionAfter(c_next_sibling, yellow);
554 await testElementInsertionAfter(c_next_sibling_child, pink);
555 await testElementInsertionAfter(c_next_sibling_descendant, pink);
556
557 await testTreeInsertionBefore(c_subject_ancestor, grey);
558 await testTreeInsertionBefore(c_subject_parent, red);
559 await testTreeInsertionBefore(c_subject, red);
560 await testTreeInsertionBefore(c_subject_child, red);
561 await testTreeInsertionBefore(c_subject_descendant, red);
562 await testTreeInsertionBefore(c_next_sibling, pink);
563 await testTreeInsertionBefore(c_next_sibling_child, pink);
564 await testTreeInsertionBefore(c_next_sibling_descendant, pink);
565
566 await testTreeInsertionAfter(c_subject_ancestor, pink);
567 await testTreeInsertionAfter(c_subject_parent, pink);
568 await testTreeInsertionAfter(c_subject, red);
569 await testTreeInsertionAfter(c_subject_child, red);
570 await testTreeInsertionAfter(c_subject_descendant, red);
571 await testTreeInsertionAfter(c_next_sibling, purple);
572 await testTreeInsertionAfter(c_next_sibling_child, pink);
573 await testTreeInsertionAfter(c_next_sibling_descendant, pink);
574
575 return true;
576 }
577
578 async function testAdjacentPosition() {
579 // https://github.com/web-platform-tests/wpt/blob/master/css/selectors/invalidation/has-in-adjacent-position.html
580
581 fixture.innerHTML = `
582 <main id="a_main">
583 <div id="a_previous_sibling">
584 <div id="a_previous_sibling_child">
585 <div id="a_previous_sibling_descendant"></div>
586 </div>
587 </div>
588 <div id="a_subject"></div>
589 <div id="a_next_sibling">
590 <div id="a_next_sibling_child">
591 <div id="a_next_sibling_descendant"></div>
592 </div>
593 </div>
594 </main>
595 `;
596
597 const grey = 'rgb(128, 128, 128)';
598 const red = 'rgb(255, 0, 0)';
599 const green = 'rgb(0, 128, 0)';
600 const blue = 'rgb(0, 0, 255)';
601 const yellow = 'rgb(255, 255, 0)';
602 const purple = 'rgb(128, 0, 128)';
603
604 function testColor(test_name, color) {
605 var actual = getComputedStyle(a_subject).backgroundColor;
606 if (actual !== color) {
607 throw new Error(test_name + ': expected ' + color + ' but got ' + actual);
608 }
609 }
610
611 async function testClassChange(element, expectedColor) {
612 element.classList.add('a_Test');
613 await rafP(() => {
614 testColor(`add .test to ${element.id}`, expectedColor);
615 });
616 element.classList.remove('a_Test');
617 await rafP(() => {
618 testColor(`remove .test from ${element.id}`, grey);
619 });
620 }
621
622 async function testElementInsertionBefore(beforeElement, expectedColor) {
623 const newElement = document.createElement('div');
624 newElement.classList.add('a_Test');
625
626 beforeElement.before(newElement);
627 await rafP(() => {
628 testColor(`insert element div.test before ${beforeElement.id}`, expectedColor);
629 });
630
631 newElement.classList.remove('a_Test');
632 await rafP(() => {
633 testColor(`remove the class 'test' from the element inserted before ${beforeElement.id}`, grey);
634 });
635
636 newElement.classList.add('a_Test');
637 await rafP(() => {
638 testColor(`add the class 'test' again to the element inserted before ${beforeElement.id}`, expectedColor);
639 });
640
641 newElement.remove();
642 await rafP(() => {
643 testColor(`remove element div.test before ${beforeElement.id}`, grey);
644 });
645
646 newElement.classList.remove('a_Test');
647
648 beforeElement.before(newElement);
649 await rafP(() => {
650 testColor(`insert element div before ${beforeElement.id}`, grey);
651 });
652
653 newElement.classList.add('a_Test');
654 await rafP(() => {
655 testColor(`add the class 'test' to the element inserted again before ${beforeElement.id}`, expectedColor);
656 });
657
658 newElement.classList.remove('a_Test');
659 await rafP(() => {
660 testColor(`remove the class 'test' from the element inserted again before ${beforeElement.id}`, grey);
661 });
662
663 newElement.remove();
664 await rafP(() => {
665 testColor(`remove element div before ${beforeElement.id}`, grey);
666 });
667
668 newElement.setAttribute('a_test_attr', '');
669
670 beforeElement.before(newElement);
671 await rafP(() => {
672 testColor(`insert element div[test_attr] before ${beforeElement.id}`, expectedColor);
673 });
674
675 newElement.removeAttribute('a_test_attr');
676
677 await rafP(() => {
678 testColor(`remove attribute div[test_attr] before ${beforeElement.id}`, grey);
679 });
680
681 newElement.setAttribute('a_test_attr', '');
682
683 await rafP(() => {
684 testColor(`insert attribute div[test_attr] before ${beforeElement.id}`, expectedColor);
685 });
686
687 newElement.remove();
688 await rafP(() => {
689 testColor(`remove element div[test_attr] before ${beforeElement.id}`, grey);
690 });
691 }
692
693 async function testElementInsertionAfter(afterElement, expectedColor) {
694 const newElement = document.createElement('div');
695 newElement.classList.add('a_Test');
696
697 afterElement.after(newElement);
698 await rafP(() => {
699 testColor(`insert element div.test after ${afterElement.id}`, expectedColor);
700 });
701
702 newElement.classList.remove('a_Test');
703 await rafP(() => {
704 testColor(`remove the class 'test' from the element inserted after ${afterElement.id}`, grey);
705 });
706
707 newElement.classList.add('a_Test');
708 await rafP(() => {
709 testColor(`add the class 'test' again to the element inserted after ${afterElement.id}`, expectedColor);
710 });
711
712 newElement.remove();
713 await rafP(() => {
714 testColor(`remove element div.test after ${afterElement.id}`, grey);
715 });
716
717 newElement.classList.remove('a_Test');
718
719 afterElement.after(newElement);
720 await rafP(() => {
721 testColor(`insert element div after ${afterElement.id}`, grey);
722 });
723
724 newElement.classList.add('a_Test');
725 await rafP(() => {
726 testColor(`add the class 'test' to the element inserted again after ${afterElement.id}`, expectedColor);
727 });
728
729 newElement.classList.remove('a_Test');
730 await rafP(() => {
731 testColor(`remove the class 'test' from the element inserted again after ${afterElement.id}`, grey);
732 });
733
734 newElement.remove();
735 await rafP(() => {
736 testColor(`remove element div after ${afterElement.id}`, grey);
737 });
738
739 newElement.setAttribute('a_test_attr', '');
740
741 afterElement.after(newElement);
742 await rafP(() => {
743 testColor(`insert element div[test_attr] after ${afterElement.id}`, expectedColor);
744 });
745
746 newElement.removeAttribute('a_test_attr');
747
748 await rafP(() => {
749 testColor(`remove attribute div[test_attr] before ${afterElement.id}`, grey);
750 });
751
752 newElement.setAttribute('a_test_attr', '');
753
754 await rafP(() => {
755 testColor(`insert attribute div[test_attr] before ${afterElement.id}`, expectedColor);
756 });
757
758 newElement.remove();
759 await rafP(() => {
760 testColor(`remove element div[test_attr] after ${afterElement.id}`, grey);
761 });
762 }
763
764 async function testTreeInsertionBefore(beforeElement, expectedColor) {
765 const newElement = document.createElement('div');
766 const newChild = document.createElement('div');
767 newChild.classList.add('a_Test');
768 newElement.appendChild(newChild);
769
770 beforeElement.before(newElement);
771 await rafP(() => {
772 testColor(`insert tree div>div.test before ${beforeElement.id}`, expectedColor);
773 });
774
775 newChild.classList.remove('a_Test');
776 await rafP(() => {
777 testColor(`remove the class 'test' from the element in the tree inserted before ${beforeElement.id}`, grey);
778 });
779
780 newChild.classList.add('a_Test');
781 await rafP(() => {
782 testColor(`add the class 'test' again to the element in the tree inserted before ${beforeElement.id}`, expectedColor);
783 });
784
785 newElement.remove();
786 await rafP(() => {
787 testColor(`remove tree div>div.test before ${beforeElement.id}`, grey);
788 });
789
790 newChild.classList.remove('a_Test');
791
792 beforeElement.before(newElement);
793 await rafP(() => {
794 testColor(`insert tree div>div before ${beforeElement.id}`, grey);
795 });
796
797 newChild.classList.add('a_Test');
798 await rafP(() => {
799 testColor(`add the class 'test' to the element in the tree inserted again before ${beforeElement.id}`, expectedColor);
800 });
801
802 newChild.classList.remove('a_Test');
803 await rafP(() => {
804 testColor(`remove the class 'test' from the element in the tree inserted again before ${beforeElement.id}`, grey);
805 });
806
807 newElement.remove();
808 await rafP(() => {
809 testColor(`remove tree div>div before ${beforeElement.id}`, grey);
810 });
811
812 newChild.setAttribute('a_test_attr', '');
813
814 beforeElement.before(newElement);
815 await rafP(() => {
816 testColor(`insert element div>div[test_attr] before ${beforeElement.id}`, expectedColor);
817 });
818
819 newChild.removeAttribute('a_test_attr');
820
821 await rafP(() => {
822 testColor(`remove attribute div[test_attr] before ${beforeElement.id}`, grey);
823 });
824
825 newChild.setAttribute('a_test_attr', '');
826
827 await rafP(() => {
828 testColor(`insert attribute div[test_attr] before ${beforeElement.id}`, expectedColor);
829 });
830
831 newElement.remove();
832 await rafP(() => {
833 testColor(`remove element div>div[test_attr] before ${beforeElement.id}`, grey);
834 });
835 }
836
837 async function testTreeInsertionAfter(afterElement, expectedColor) {
838 const newElement = document.createElement('div');
839 const newChild = document.createElement('div');
840 newChild.classList.add('a_Test');
841 newElement.appendChild(newChild);
842
843 afterElement.after(newElement);
844 await rafP(() => {
845 testColor(`insert tree div>div.test after ${afterElement.id}`, expectedColor);
846 });
847
848 newChild.classList.remove('a_Test');
849 await rafP(() => {
850 testColor(`remove the class 'test' from the element in the tree inserted after ${afterElement.id}`, grey);
851 });
852
853 newChild.classList.add('a_Test');
854 await rafP(() => {
855 testColor(`add the class 'test' again to the element in the tree inserted after ${afterElement.id}`, expectedColor);
856 });
857
858 newElement.remove();
859 await rafP(() => {
860 testColor(`remove tree div>div.test after ${afterElement.id}`, grey);
861 });
862
863 newChild.classList.remove('a_Test');
864
865 afterElement.after(newElement);
866 await rafP(() => {
867 testColor(`insert tree div>div after ${afterElement.id}`, grey);
868 });
869
870 newChild.classList.add('a_Test');
871 await rafP(() => {
872 testColor(`add the class 'test' to the element in the tree inserted again after ${afterElement.id}`, expectedColor);
873 });
874
875 newChild.classList.remove('a_Test');
876 await rafP(() => {
877 testColor(`remove the class 'test' from the element in the tree inserted again after ${afterElement.id}`, grey);
878 });
879
880 newElement.remove();
881 await rafP(() => {
882 testColor(`remove tree div>div after ${afterElement.id}`, grey);
883 });
884
885 newChild.setAttribute('a_test_attr', '');
886
887 afterElement.after(newElement);
888 await rafP(() => {
889 testColor(`insert element div>div[test_attr] after ${afterElement.id}`, expectedColor);
890 });
891
892 newChild.removeAttribute('a_test_attr');
893
894 await rafP(() => {
895 testColor(`remove attribute div[test_attr] before ${afterElement.id}`, grey);
896 });
897
898 newChild.setAttribute('a_test_attr', '');
899
900 await rafP(() => {
901 testColor(`insert attribute div[test_attr] before ${afterElement.id}`, expectedColor);
902 });
903
904 newElement.remove();
905 await rafP(() => {
906 testColor(`remove element div>div[test_attr] after ${afterElement.id}`, grey);
907 });
908 }
909
910 await rafP(() => {
911 testColor('Initial color', grey);
912 });
913
914 await testClassChange(a_previous_sibling, grey);
915 await testClassChange(a_previous_sibling_child, green);
916 await testClassChange(a_previous_sibling_descendant, red);
917 await testClassChange(a_subject, blue);
918 await testClassChange(a_next_sibling, yellow);
919 await testClassChange(a_next_sibling_child, purple);
920 await testClassChange(a_next_sibling_descendant, purple);
921
922 await testElementInsertionBefore(a_previous_sibling, grey);
923 await testElementInsertionBefore(a_previous_sibling_child, green);
924 await testElementInsertionBefore(a_previous_sibling_descendant, red);
925 await testElementInsertionBefore(a_subject, grey);
926 await testElementInsertionBefore(a_next_sibling, yellow);
927 await testElementInsertionBefore(a_next_sibling_child, purple);
928 await testElementInsertionBefore(a_next_sibling_descendant, purple);
929
930 await testElementInsertionAfter(a_previous_sibling, grey);
931 await testElementInsertionAfter(a_previous_sibling_child, green);
932 await testElementInsertionAfter(a_previous_sibling_descendant, red);
933 await testElementInsertionAfter(a_subject, yellow);
934 await testElementInsertionAfter(a_next_sibling, yellow);
935 await testElementInsertionAfter(a_next_sibling_child, purple);
936 await testElementInsertionAfter(a_next_sibling_descendant, purple);
937
938 await testTreeInsertionBefore(a_previous_sibling, grey);
939 await testTreeInsertionBefore(a_previous_sibling_child, red);
940 await testTreeInsertionBefore(a_previous_sibling_descendant, red);
941 await testTreeInsertionBefore(a_subject, green);
942 await testTreeInsertionBefore(a_next_sibling, purple);
943 await testTreeInsertionBefore(a_next_sibling_child, purple);
944 await testTreeInsertionBefore(a_next_sibling_descendant, purple);
945
946 await testTreeInsertionAfter(a_previous_sibling, green);
947 await testTreeInsertionAfter(a_previous_sibling_child, red);
948 await testTreeInsertionAfter(a_previous_sibling_descendant, red);
949 await testTreeInsertionAfter(a_subject, purple);
950 await testTreeInsertionAfter(a_next_sibling, purple);
951 await testTreeInsertionAfter(a_next_sibling_child, purple);
952 await testTreeInsertionAfter(a_next_sibling_descendant, purple);
953
954 return true;
955 }
956
957 async function testInvalidation() {
958 // https://github.com/web-platform-tests/wpt/blob/master/css/selectors/invalidation/attribute-or-elemental-selectors-in-has.html
959
960 fixture.innerHTML = `
961 <main id="b_main">
962 <div id="b_div_subject" class="b_subject">
963 <div id="b_div_child">
964 <div id="b_div_grandchild"></div>
965 </div>
966 </div>
967 </main>
968 `;
969
970 var grey = 'rgb(128, 128, 128)';
971 var red = 'rgb(255, 0, 0)';
972 var green = 'rgb(0, 128, 0)';
973 var blue = 'rgb(0, 0, 255)';
974 var yellow = 'rgb(255, 255, 0)';
975 var yellowgreen = 'rgb(154, 205, 50)';
976
977 function test_div(test_name, el, color) {
978 var actual = getComputedStyle(el).backgroundColor;
979 if (actual !== color) {
980 throw new Error(test_name + ': div#' + el.id + '.color; expected ' + color + ' but got ' + actual);
981 }
982 }
983
984 test_div('initial_color', b_div_subject, grey);
985 test_div('initial_color', b_div_child, grey);
986 test_div('initial_color', b_div_grandchild, grey);
987
988 b_div_child.classList.add('b_child');
989 await rafP(() => {
990 test_div('add .b_child to #b_div_child', b_div_subject, red);
991 });
992
993 b_div_child.classList.remove('b_child');
994 await rafP(() => {
995 test_div('remove .b_child from #b_div_child', b_div_subject, grey);
996 });
997
998 b_div_grandchild.classList.add('b_child');
999 await rafP(() => {
1000 test_div('add .b_child to #b_div_grandchild', b_div_subject, grey);
1001 });
1002 b_div_grandchild.classList.remove('b_child');
1003 await rafP(() => {
1004 test_div('remove .b_child from #b_div_grandchild', b_div_subject, grey);
1005 });
1006
1007 b_div_child.classList.add('b_descendant');
1008 await rafP(() => {
1009 test_div('add .b_descendant to #b_div_child', b_div_subject, green);
1010 });
1011 b_div_child.classList.remove('b_descendant');
1012 await rafP(() => {
1013 test_div('remove .b_descendant from #b_div_child', b_div_subject, grey);
1014 });
1015
1016 b_div_grandchild.classList.add('b_descendant');
1017 await rafP(() => {
1018 test_div('add .b_descendant to #b_div_grandchild', b_div_subject, green);
1019 });
1020 b_div_grandchild.classList.remove('b_descendant');
1021 await rafP(() => {
1022 test_div('remove .b_descendant from #b_div_grandchild', b_div_subject, grey);
1023 });
1024
1025 b_div_grandchild.setAttribute('attrname', 'b_descendant');
1026 await rafP(() => {
1027 test_div('set b_descendant to #b_div_grandchild[attrname]', b_div_subject, blue);
1028 });
1029 b_div_grandchild.setAttribute('attrname', '');
1030 await rafP(() => {
1031 test_div('clear #b_div_grandchild[attrname]', b_div_subject, grey);
1032 });
1033
1034 b_div_grandchild.id = 'b_div_descendant';
1035 await rafP(() => {
1036 test_div('change #b_div_grandchild to #b_div_descendant', b_div_subject, yellow);
1037 });
1038 b_div_descendant.id = 'b_div_grandchild';
1039 await rafP(() => {
1040 test_div('change #b_div_descendant to #b_div_grandchild', b_div_subject, grey);
1041 });
1042
1043 {
1044 var b_descendant = document.createElement('b_descendant');
1045 b_div_subject.appendChild(b_descendant);
1046 await rafP(() => {
1047 test_div('add b_descendant to #b_div_subject', b_div_subject, yellowgreen);
1048 });
1049 b_div_subject.removeChild(b_descendant);
1050 await rafP(() => {
1051 test_div('remove b_descendant from #b_div_subject', b_div_subject, grey);
1052 });
1053 }
1054
1055 {
1056 var div = document.createElement('div');
1057 var b_descendant = document.createElement('b_descendant');
1058 div.appendChild(b_descendant);
1059 b_div_subject.appendChild(div);
1060 await rafP(() => {
1061 test_div('add "div > b_descendant" to #b_div_subject', b_div_subject, yellowgreen);
1062 });
1063 b_div_subject.removeChild(div);
1064 await rafP(() => {
1065 test_div('remove "div > b_descendant" from #b_div_subject', b_div_subject, grey);
1066 });
1067 }
1068
1069 {
1070 var child = document.createElement('div');
1071 child.classList.add('b_child');
1072 b_div_subject.appendChild(child);
1073 await rafP(() => {
1074 test_div('add div.b_child to #b_div_subject', b_div_subject, red);
1075 });
1076 b_div_subject.removeChild(child);
1077 await rafP(() => {
1078 test_div('remove div.b_child from #b_div_subject', b_div_subject, grey);
1079 });
1080 }
1081
1082 {
1083 var b_descendant = document.createElement('div');
1084 b_descendant.classList.add('b_descendant');
1085 var div = document.createElement('div');
1086 div.appendChild(b_descendant);
1087 b_div_subject.appendChild(div);
1088 await rafP(() => {
1089 test_div('add "div > div.b_descendant" to #b_div_subject', b_div_subject, green);
1090 });
1091 b_div_subject.removeChild(div);
1092 await rafP(() => {
1093 test_div('remove "div > div.b_descendant" from #b_div_subject', b_div_subject, grey);
1094 });
1095 }
1096
1097 {
1098 var child = document.createElement('div');
1099 child.id = 'b_div_descendant';
1100 b_div_subject.appendChild(child);
1101 await rafP(() => {
1102 test_div('add div#b_div_descendant to #b_div_subject', b_div_subject, yellow);
1103 });
1104 b_div_subject.removeChild(child);
1105 await rafP(() => {
1106 test_div('remove div#b_div_descendant from #b_div_subject', b_div_subject, grey);
1107 });
1108 }
1109
1110 {
1111 var descendant = document.createElement('div');
1112 descendant.id = 'b_div_descendant';
1113 var div = document.createElement('div');
1114 div.appendChild(descendant);
1115 b_div_subject.appendChild(div);
1116 await rafP(() => {
1117 test_div('add "div#b_div_descendant" to #b_div_subject', b_div_subject, yellow);
1118 });
1119 b_div_subject.removeChild(div);
1120 await rafP(() => {
1121 test_div('remove "div#b_div_descendant" from #b_div_subject', b_div_subject, grey);
1122 });
1123 }
1124
1125 {
1126 var child = document.createElement('div');
1127 child.setAttribute('attrname', 'b_descendant');
1128 b_div_subject.appendChild(child);
1129 await rafP(() => {
1130 test_div('add div[attrname] to #b_div_subject', b_div_subject, blue);
1131 });
1132 b_div_subject.removeChild(child);
1133 await rafP(() => {
1134 test_div('remove div[attrname] from #b_div_subject', b_div_subject, grey);
1135 });
1136 }
1137
1138 {
1139 var descendant = document.createElement('div');
1140 descendant.setAttribute('attrname', 'b_descendant');
1141 var div = document.createElement('div');
1142 div.appendChild(descendant);
1143 b_div_subject.appendChild(div);
1144 await rafP(() => {
1145 test_div('add "div > div[attrname]" to #b_div_subject', b_div_subject, blue);
1146 });
1147 b_div_subject.removeChild(div);
1148 await rafP(() => {
1149 test_div('remove "div > div[attrname]" from #b_div_subject', b_div_subject, grey);
1150 });
1151 }
1152
1153 return true;
1154 }
1155
1156 async function testNestedHas() {
1157 // https://github.com/web-platform-tests/wpt/blob/master/css/selectors/invalidation/has-pseudo-class.html
1158
1159 fixture.innerHTML = `
1160 <main id="nested_main">
1161 <div id="a">
1162 <div id="b">
1163 <div id="c">
1164 </div>
1165 </div>
1166 </div>
1167 </main>
1168 `;
1169
1170 const red = 'rgb(255, 0, 0)';
1171
1172 function testColor(el, color) {
1173 var actual = getComputedStyle(el).color;
1174 if (actual === color) {
1175 throw new Error('nested :has should not be allowed : div#' + el.id + '.color; did not expected ' + color + ' but got ' + actual + ' anyway.');
1176 }
1177 }
1178
1179 await rafP(() => {
1180 testColor(document.getElementById('a'), red);
1181 });
1182
1183 return true;
1184 }
1185
1186 async function testPseudos() {
1187 // https://github.com/web-platform-tests/wpt/blob/master/css/selectors/invalidation/has-pseudo-class.html
1188
1189 fixture.innerHTML = `
1190 <main id="pseudo_main">
1191 <div id="a">
1192 <div id="b"></div>
1193 </div>
1194 </main>
1195 `;
1196
1197 var green = 'rgb(0, 128, 0)';
1198
1199 function testColor(el, pseudo, color) {
1200 var actual = getComputedStyle(el, pseudo).color;
1201 if (actual !== color) {
1202 throw new Error('pseudo elements after :has should work : div#' + el.id + '.color; expected ' + color + ' but got ' + actual);
1203 }
1204 }
1205
1206 await rafP(() => {
1207 testColor(document.getElementById('a'), '::before', green);
1208 });
1209
1210 return true;
1211 }
1212 </script>
1213 </body>
1214 </html>