css/css-conditional/container-queries/style-container-for-shadow-dom.html - external/w3c/web-platform-tests - Git at Google

 <!doctype html>
 <meta charset="utf-8">
 <title>CSS Container Queries Test: style query container for Shadow DOM</title>
 <link rel="help" href="https://drafts.csswg.org/css-conditional-5/#query-container">
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="support/cq-testcommon.js"></script>

 <div id="ancestor-across-root">
   <div style="--foo: bar">
     <template shadowrootmode="open">
       <style>
         @container style(--foo: bar) {
           #t1 { color: green; }
         }
       </style>
       <div id="t1"></div>
     </template>
   </div>
 </div>

 <div id="ancestor-slotting">
   <div style="--foo: bar">
     <template shadowrootmode="open">
       <div style="--foo: baz">
         <slot></slot>
       </div>
     </template>
     <style>
       @container style(--foo: baz) {
         #t2 { color: green; }
       }
     </style>
     <div id="t2"></div>
   </div>
 </div>

 <div id="ancestor-slotted">
   <div style="--foo: baz">
     <template shadowrootmode="open">
       <style>
         @container style(--foo: bar) {
           ::slotted(#t3) { color: green; }
         }
       </style>
       <slot style="--foo: bar"></slot>
     </template>
     <div id="t3"></div>
   </div>
 </div>

 <div id="ancestor-host" style="--foo: bar">
   <div id="t4">
     <template shadowrootmode="open">
       <style>
         @container style(--foo: bar) {
           :host(#t4) { color: green; }
         }
       </style>
     </template>
   </div>
 </div>

 <div id="ancestor-part">
   <div style="--foo: bar">
     <template shadowrootmode="open">
       <div style="--foo: baz">
         <span id="t5" part="part"></span>
       </div>
     </template>
     <style>
       @container style(--foo: baz) {
         #ancestor-part > div::part(part) { color: green; }
       }
     </style>
   </div>
 </div>

 <div id="ancestor-slotted-before">
   <div>
     <template shadowrootmode="open">
       <style>
         @container style(--foo: baz) {
           ::slotted(#t6)::before {
             content: "X";
             color: green;
           }
         }
       </style>
       <slot style="--foo: bar"></slot>
     </template>
     <div id="t6" style="--foo: baz"></div>
   </div>
 </div>

 <div id="ancestor-host-before">
   <div id="t7" style="--foo: bar">
     <template shadowrootmode="open">
       <style>
         @container style(--foo: bar) {
           :host(#t7)::before {
             content: "X";
             color: green;
           }
         }
       </style>
     </template>
   </div>
 </div>

 <div id="ancestor-part-before">
   <style>
     @container style(--foo: quz) {
       #ancestor-part-before > div::part(part)::before {
         content: "X";
         color: green;
       }
     }
   </style>
   <div style="--foo: bar">
     <template shadowrootmode="open">
       <div style="--foo: baz">
         <span id="t8" part="part" style="--foo: quz"></span>
       </div>
     </template>
   </div>
 </div>

 <div id="ancestor-inner-part">
   <style>
     @container style(--foo: quz) {
       #ancestor-inner-part > div::part(inner-part) { color: green; }
     }
   </style>
   <div style="--foo: bar">
     <template shadowrootmode="open">
       <div exportparts="inner-part" style="--foo: baz">
         <template shadowrootmode="open">
           <div style="--foo: quz">
             <span id="t9" part="inner-part"></span>
           </div>
         </template>
       </div>
     </template>
   </div>
 </div>

 <div id="ancestor-slot-fallback">
   <div><template shadowrootmode="open">
     <style>
       @container style(--foo: bar) {
         #t10 { color: green; }
       }
     </style>
     <div>
       <slot style="--foo: bar"><span id="t10"></span></slot>
     </div>
   </template></div>
 </div>

 <div id="container-for-part">
   <div>
     <template shadowrootmode="open">
       <div style="--foo: bar">
         <span id="t11" part="part"></span>
       </div>
     </template>
     <style>
       @container style(--foo: bar) {
         #container-for-part > div::part(part) { color: green; }
       }
     </style>
   </div>
 </div>

 <div id="inner-scope-host-part" style="--foo: bar">
   <div>
     <template shadowrootmode="open">
       <style>
         @container style(--foo: baz) {
           :host::part(part) { color: green; }
         }
       </style>
       <div style="--foo: baz">
         <span id="t12" part="part"></span>
       </div>
     </template>
   </div>
 </div>

 <script>
   setup(() => {
     assert_implements_style_container_queries();
   });

   const green = "rgb(0, 128, 0)";

   test(() => {
     const t1 = document.querySelector("#ancestor-across-root > div").shadowRoot.querySelector("#t1");
     assert_equals(getComputedStyle(t1).color, green);
   }, "Match container in outer tree");

   test(() => {
     const t2 = document.querySelector("#t2");
     assert_equals(getComputedStyle(t2).color, green);
   }, "Match container in the shadow tree for a host child in the host child's tree scope");

   test(() => {
     const t3 = document.querySelector("#t3");
     assert_equals(getComputedStyle(t3).color, green);
   }, "Match <slot> as a container for ::slotted element");

   test(() => {
     const t4 = document.querySelector("#t4");
     assert_equals(getComputedStyle(t4).color, green);
   }, "Match container in outer tree for :host");

   test(() => {
     const t5 = document.querySelector("#ancestor-part > div").shadowRoot.querySelector("#t5");
     assert_equals(getComputedStyle(t5).color, green);
   }, "Match ::part's parent in the shadow tree as the container for ::part");

   test(() => {
     const t6 = document.querySelector("#t6");
     assert_equals(getComputedStyle(t6, "::before").color, green);
   }, "Match ::slotted as a container for its ::before");

   test(() => {
     const t7 = document.querySelector("#t7");
     assert_equals(getComputedStyle(t7, "::before").color, green);
   }, "Match container in outer tree for :host::before");

   test(() => {
     const t8 = document.querySelector("#ancestor-part-before > div").shadowRoot.querySelector("#t8");
     assert_equals(getComputedStyle(t8, "::before").color, green);
   }, "Match the ::part as a container for ::before on ::part elements");

   test(() => {
     const outerhost = document.querySelector("#ancestor-inner-part > div");
     const innerhost = outerhost.shadowRoot.querySelector("div");
     const t9 = innerhost.shadowRoot.querySelector("#t9");
     assert_equals(getComputedStyle(t9).color, green);
   }, "Match container for ::part selector in inner shadow tree for exportparts");

   test(() => {
     const t10 = document.querySelector("#ancestor-slot-fallback > div").shadowRoot.querySelector("#t10");
     assert_equals(getComputedStyle(t10).color, green);
   }, "Match container for slot light tree child fallback");

   test(() => {
     const t11 = document.querySelector("#container-for-part > div").shadowRoot.querySelector("#t11");
     assert_equals(getComputedStyle(t11).color, green);
   }, "Should match parent container inside shadow tree for ::part()");

   test(() => {
     const t12 = document.querySelector("#inner-scope-host-part > div").shadowRoot.querySelector("#t12");
     assert_equals(getComputedStyle(t12).color, green);
   }, "A :host::part rule matching a container in the shadow tree");

 </script>
	<!doctype html>
	<meta charset="utf-8">
	<title>CSS Container Queries Test: style query container for Shadow DOM</title>
	<link rel="help" href="https://drafts.csswg.org/css-conditional-5/#query-container">
	<script src="/resources/testharness.js"></script>
	<script src="/resources/testharnessreport.js"></script>
	<script src="support/cq-testcommon.js"></script>

	<div id="ancestor-across-root">
	<div style="--foo: bar">
	<template shadowrootmode="open">
	<style>
	@container style(--foo: bar) {
	#t1 { color: green; }
	}
	</style>
	<div id="t1"></div>
	</template>
	</div>
	</div>

	<div id="ancestor-slotting">
	<div style="--foo: bar">
	<template shadowrootmode="open">
	<div style="--foo: baz">
	<slot></slot>
	</div>
	</template>
	<style>
	@container style(--foo: baz) {
	#t2 { color: green; }
	}
	</style>
	<div id="t2"></div>
	</div>
	</div>

	<div id="ancestor-slotted">
	<div style="--foo: baz">
	<template shadowrootmode="open">
	<style>
	@container style(--foo: bar) {
	::slotted(#t3) { color: green; }
	}
	</style>
	<slot style="--foo: bar"></slot>
	</template>
	<div id="t3"></div>
	</div>
	</div>

	<div id="ancestor-host" style="--foo: bar">
	<div id="t4">
	<template shadowrootmode="open">
	<style>
	@container style(--foo: bar) {
	:host(#t4) { color: green; }
	}
	</style>
	</template>
	</div>
	</div>

	<div id="ancestor-part">
	<div style="--foo: bar">
	<template shadowrootmode="open">
	<div style="--foo: baz">
	<span id="t5" part="part"></span>
	</div>
	</template>
	<style>
	@container style(--foo: baz) {
	#ancestor-part > div::part(part) { color: green; }
	}
	</style>
	</div>
	</div>

	<div id="ancestor-slotted-before">
	<div>
	<template shadowrootmode="open">
	<style>
	@container style(--foo: baz) {
	::slotted(#t6)::before {
	content: "X";
	color: green;
	}
	}
	</style>
	<slot style="--foo: bar"></slot>
	</template>
	<div id="t6" style="--foo: baz"></div>
	</div>
	</div>

	<div id="ancestor-host-before">
	<div id="t7" style="--foo: bar">
	<template shadowrootmode="open">
	<style>
	@container style(--foo: bar) {
	:host(#t7)::before {
	content: "X";
	color: green;
	}
	}
	</style>
	</template>
	</div>
	</div>

	<div id="ancestor-part-before">
	<style>
	@container style(--foo: quz) {
	#ancestor-part-before > div::part(part)::before {
	content: "X";
	color: green;
	}
	}
	</style>
	<div style="--foo: bar">
	<template shadowrootmode="open">
	<div style="--foo: baz">
	<span id="t8" part="part" style="--foo: quz"></span>
	</div>
	</template>
	</div>
	</div>

	<div id="ancestor-inner-part">
	<style>
	@container style(--foo: quz) {
	#ancestor-inner-part > div::part(inner-part) { color: green; }
	}
	</style>
	<div style="--foo: bar">
	<template shadowrootmode="open">
	<div exportparts="inner-part" style="--foo: baz">
	<template shadowrootmode="open">
	<div style="--foo: quz">
	<span id="t9" part="inner-part"></span>
	</div>
	</template>
	</div>
	</template>
	</div>
	</div>

	<div id="ancestor-slot-fallback">
	<div><template shadowrootmode="open">
	<style>
	@container style(--foo: bar) {
	#t10 { color: green; }
	}
	</style>
	<div>
	<slot style="--foo: bar"><span id="t10"></span></slot>
	</div>
	</template></div>
	</div>

	<div id="container-for-part">
	<div>
	<template shadowrootmode="open">
	<div style="--foo: bar">
	<span id="t11" part="part"></span>
	</div>
	</template>
	<style>
	@container style(--foo: bar) {
	#container-for-part > div::part(part) { color: green; }
	}
	</style>
	</div>
	</div>

	<div id="inner-scope-host-part" style="--foo: bar">
	<div>
	<template shadowrootmode="open">
	<style>
	@container style(--foo: baz) {
	:host::part(part) { color: green; }
	}
	</style>
	<div style="--foo: baz">
	<span id="t12" part="part"></span>
	</div>
	</template>
	</div>
	</div>

	<script>
	setup(() => {
	assert_implements_style_container_queries();
	});

	const green = "rgb(0, 128, 0)";

	test(() => {
	const t1 = document.querySelector("#ancestor-across-root > div").shadowRoot.querySelector("#t1");
	assert_equals(getComputedStyle(t1).color, green);
	}, "Match container in outer tree");

	test(() => {
	const t2 = document.querySelector("#t2");
	assert_equals(getComputedStyle(t2).color, green);
	}, "Match container in the shadow tree for a host child in the host child's tree scope");

	test(() => {
	const t3 = document.querySelector("#t3");
	assert_equals(getComputedStyle(t3).color, green);
	}, "Match <slot> as a container for ::slotted element");

	test(() => {
	const t4 = document.querySelector("#t4");
	assert_equals(getComputedStyle(t4).color, green);
	}, "Match container in outer tree for :host");

	test(() => {
	const t5 = document.querySelector("#ancestor-part > div").shadowRoot.querySelector("#t5");
	assert_equals(getComputedStyle(t5).color, green);
	}, "Match ::part's parent in the shadow tree as the container for ::part");

	test(() => {
	const t6 = document.querySelector("#t6");
	assert_equals(getComputedStyle(t6, "::before").color, green);
	}, "Match ::slotted as a container for its ::before");

	test(() => {
	const t7 = document.querySelector("#t7");
	assert_equals(getComputedStyle(t7, "::before").color, green);
	}, "Match container in outer tree for :host::before");

	test(() => {
	const t8 = document.querySelector("#ancestor-part-before > div").shadowRoot.querySelector("#t8");
	assert_equals(getComputedStyle(t8, "::before").color, green);
	}, "Match the ::part as a container for ::before on ::part elements");

	test(() => {
	const outerhost = document.querySelector("#ancestor-inner-part > div");
	const innerhost = outerhost.shadowRoot.querySelector("div");
	const t9 = innerhost.shadowRoot.querySelector("#t9");
	assert_equals(getComputedStyle(t9).color, green);
	}, "Match container for ::part selector in inner shadow tree for exportparts");

	test(() => {
	const t10 = document.querySelector("#ancestor-slot-fallback > div").shadowRoot.querySelector("#t10");
	assert_equals(getComputedStyle(t10).color, green);
	}, "Match container for slot light tree child fallback");

	test(() => {
	const t11 = document.querySelector("#container-for-part > div").shadowRoot.querySelector("#t11");
	assert_equals(getComputedStyle(t11).color, green);
	}, "Should match parent container inside shadow tree for ::part()");

	test(() => {
	const t12 = document.querySelector("#inner-scope-host-part > div").shadowRoot.querySelector("#t12");
	assert_equals(getComputedStyle(t12).color, green);
	}, "A :host::part rule matching a container in the shadow tree");

	</script>