firefox-main/testing/web-platform/tests/css/css-anchor-position/position-area-computed.html

Source code

Revision control

Copy as Markdown

Other Tools

Test Info:

<!DOCTYPE html>
<title>CSS Anchor Positioning: position-area getComputedStyle()</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/css/support/computed-testcommon.js"></script>
<script src="/css/support/inheritance-testcommon.js"></script>
<div id="container">
<div id="target"></div>
</div>
<script>
// Keywords that refer to the physical horizontal/vertical axes.
const horizontal = [
"left",
"right",
"span-left",
"span-right",
"x-start",
"x-end",
"span-x-start",
"span-x-end",
"x-self-start",
"x-self-end",
"span-x-self-start",
"span-x-self-end"
];
const vertical = [
"top",
"bottom",
"span-top",
"span-bottom",
"y-start",
"y-end",
"span-y-start",
"span-y-end",
"y-self-start",
"y-self-end",
"span-y-self-start",
"span-y-self-end"
];
// Keywords that refer to the logical block/inline axis.
// Key is the full form of the keyword, value is the equivalent reduced keyword.
const inline = {
"inline-start": "start",
"inline-end": "end",
"span-inline-start": "span-start",
"span-inline-end": "span-end",
}
const block = {
"block-start": "start",
"block-end": "end",
"span-block-start": "span-start",
"span-block-end": "span-end",
}
const self_inline = {
"self-inline-start": "self-start",
"self-inline-end": "self-end",
"span-self-inline-start": "span-self-start",
"span-self-inline-end": "span-self-end",
}
const self_block = {
"self-block-start": "self-start",
"self-block-end": "self-end",
"span-self-block-start": "span-self-start",
"span-self-block-end": "span-self-end",
}
// Keywords that refer to an ambiguous axis.
// Key is the keyword, value is the equivalent keyword if the original keyword refers
// to a block or inline axis.
const start_end = {
"start": { "block": "block-start", "inline": "inline-start" },
"end": { "block": "block-end", "inline": "inline-end" },
"span-start": { "block": "span-block-start", "inline": "span-inline-start" },
"span-end": { "block": "span-block-end", "inline": "span-inline-end" },
};
const self_start_end = {
"self-start": { "block": "self-block-start", "inline": "self-inline-start" },
"self-end": { "block": "self-block-end", "inline": "self-inline-end" },
"span-self-start": { "block": "span-self-block-start", "inline": "span-self-inline-start" },
"span-self-end": { "block": "span-self-block-end", "inline": "span-self-inline-end" },
};
function test_single_keyword(keywords) {
for (const keyword of keywords)
test_computed_value("position-area", keyword);
}
function test_physical_keywords(horizontal_keywords, vertical_keywords) {
for (const horizontal of horizontal_keywords) {
for (const vertical of vertical_keywords) {
test_computed_value("position-area", `${horizontal} ${vertical}`);
test_computed_value("position-area", `${vertical} ${horizontal}`, `${horizontal} ${vertical}`);
}
}
for (const keyword of horizontal_keywords) {
test_computed_value("position-area", `${keyword} span-all`, keyword);
test_computed_value("position-area", `span-all ${keyword}`, keyword);
test_computed_value("position-area", `${keyword} center`);
test_computed_value("position-area", `center ${keyword}`, `${keyword} center`);
}
for (const keyword of vertical_keywords) {
test_computed_value("position-area", `span-all ${keyword}`, keyword);
test_computed_value("position-area", `${keyword} span-all`, keyword);
test_computed_value("position-area", `center ${keyword}`);
test_computed_value("position-area", `${keyword} center`, `center ${keyword}`);
}
}
function test_unambiguous_logical_keywords(block_keywords, inline_keywords) {
for (const [block_long_keyword, block_short_keyword] of Object.entries(block_keywords)) {
for (const [inline_long_keyword, inline_short_keyword] of Object.entries(inline_keywords)) {
let expected_computed = `${block_short_keyword} ${inline_short_keyword}`;
if (block_short_keyword == inline_short_keyword)
expected_computed = block_short_keyword;
test_computed_value("position-area", `${block_long_keyword} ${inline_long_keyword}`, expected_computed);
test_computed_value("position-area", `${inline_long_keyword} ${block_long_keyword}`, expected_computed);
}
}
for (const [long_keyword, short_keyword] of Object.entries(block_keywords)) {
test_computed_value("position-area", `${long_keyword} span-all`, long_keyword);
test_computed_value("position-area", `span-all ${long_keyword}`, long_keyword);
test_computed_value("position-area", `${long_keyword} center`, `${short_keyword} center`);
test_computed_value("position-area", `center ${long_keyword}`, `${short_keyword} center`);
}
for (const [long_keyword, short_keyword] of Object.entries(inline_keywords)) {
test_computed_value("position-area", `${long_keyword} span-all`, long_keyword);
test_computed_value("position-area", `span-all ${long_keyword}`, long_keyword);
test_computed_value("position-area", `${long_keyword} center`, `center ${short_keyword}`);
test_computed_value("position-area", `center ${long_keyword}`, `center ${short_keyword}`);
}
}
function test_ambiguous_logical_keywords(keywords) {
for (const keyword1 of Object.keys(keywords)) {
for (const keyword2 of Object.keys(keywords)) {
if (keyword1 == keyword2)
test_computed_value("position-area", `${keyword1} ${keyword2}`, `${keyword1}`);
else
test_computed_value("position-area", `${keyword1} ${keyword2}`);
}
}
for (const [keyword, { block: block_keyword, inline: inline_keyword }] of Object.entries(keywords)) {
test_computed_value("position-area", `${keyword} span-all`, block_keyword);
test_computed_value("position-area", `span-all ${keyword}`, inline_keyword);
test_computed_value("position-area", `${keyword} center`);
test_computed_value("position-area", `center ${keyword}`);
};
}
// Test computed value when position-area is a single keyword.
test_computed_value("position-area", "none");
test_computed_value("position-area", "span-all");
test_computed_value("position-area", "center");
test_single_keyword(horizontal);
test_single_keyword(vertical);
test_single_keyword(Object.keys(inline));
test_single_keyword(Object.keys(block));
test_single_keyword(Object.keys(self_inline));
test_single_keyword(Object.keys(self_block));
test_single_keyword(Object.keys(start_end));
test_single_keyword(Object.keys(self_start_end));
// Test computed value when position-area are two keywords.
test_physical_keywords(horizontal, vertical);
test_unambiguous_logical_keywords(block, inline);
test_unambiguous_logical_keywords(self_block, self_inline);
test_ambiguous_logical_keywords(start_end);
test_ambiguous_logical_keywords(self_start_end);
test_computed_value("position-area", "span-all span-all", "span-all");
test_computed_value("position-area", "span-all center");
test_computed_value("position-area", "center span-all");
test_computed_value("position-area", "center center", "center");
assert_not_inherited("position-area", "none", "span-all");
</script>