diff --git a/crates/svg/src/import/css.rs b/crates/svg/src/import/css.rs
index 4db4b22f1..92b61a70a 100644
--- a/crates/svg/src/import/css.rs
+++ b/crates/svg/src/import/css.rs
@@ -485,337 +485,4 @@ impl Styles {
 }
 
 #[cfg(test)]
-mod tests {
-    use proptest::prelude::*;
-
-    use super::*;
-
-    #[test]
-    fn important_flag_is_case_insensitive() {
-        for s in ["fill: red !IMPORTANT", "fill: red !Important", "fill: red ! important"] {
-            assert_eq!(parse_decls(s), [("fill".to_string(), "red".to_string(), true)], "{s}");
-        }
-        assert_eq!(parse_decls("fill: red !importantx"), [("fill".to_string(), "red !importantx".to_string(), false)]);
-    }
-
-    #[test]
-    fn semicolons_in_quotes_and_parens_do_not_split() {
-        let d = |k: &str, v: &str| (k.to_string(), v.to_string(), false);
-        assert_eq!(parse_decls("font-family:'A;B'; fill:red"), [d("font-family", "'A;B'"), d("fill", "red")]);
-        assert_eq!(parse_decls("font-family:\"A;B\"; fill:red"), [d("font-family", "\"A;B\""), d("fill", "red")]);
-        assert_eq!(
-            parse_decls("fill:url(data:image/svg+xml;base64,AAA); stroke:red"),
-            [d("fill", "url(data:image/svg+xml;base64,AAA)"), d("stroke", "red")]
-        );
-        let _ = parse_decls("font-family:'A;B; fill:red");
-    }
-
-    fn with_doc(svg: &str, f: impl FnOnce(&roxmltree::Document, &Styles)) {
-        let doc = roxmltree::Document::parse(svg).unwrap();
-        let st = Styles::new(&doc);
-        f(&doc, &st);
-    }
-
-    fn by_id<'a, 'i>(doc: &'a roxmltree::Document<'i>, id: &str) -> XNode<'a, 'i> {
-        doc.descendants().find(|n| n.attribute("id") == Some(id)).unwrap()
-    }
-
-    #[test]
-    fn selectors_and_precedence() {
-        with_doc(
-            r#"<svg xmlns="http://www.w3.org/2000/svg"><style>
-            /* comment { fill: red } */
-            @media print { text { fill: red } }
-            @import url(x.css);
-            text { fill: #111; font-size: 9px }
-            g text { fill: #222 }
-            g > text.a { fill: #333 }
-            .a.b { stroke: blue }
-            #t2 { fill: #444 }
-            [data-k=v] { font-weight: bold }
-            text:first-child, text ~ text { fill: red }
-            .imp { fill: #555 !important }
-            </style>
-            <text id="t0">x</text>
-            <g><text id="t1" class="a b" fill="green">x</text>
-               <g><text id="t2" class="a" style="fill:#666">x</text></g>
-               <text id="t3" class="a imp" style="fill:#777" data-k="v">x</text></g>
-            </svg>"#,
-            |doc, st| {
-                assert_eq!(st.own(by_id(doc, "t0"), "fill").as_deref(), Some("#111"));
-                assert_eq!(st.own(by_id(doc, "t1"), "fill").as_deref(), Some("#333"), "child + class beats descendant");
-                assert_eq!(st.own(by_id(doc, "t1"), "stroke").as_deref(), Some("blue"), "multiple classes");
-                assert_eq!(st.own(by_id(doc, "t2"), "fill").as_deref(), Some("#666"), "style attribute beats #id");
-                assert_eq!(st.own(by_id(doc, "t3"), "fill").as_deref(), Some("#555"), "!important beats style");
-                assert_eq!(st.own(by_id(doc, "t3"), "font-weight").as_deref(), Some("bold"));
-                assert_eq!(st.own(by_id(doc, "t2"), "stroke"), None, "`.a.b` needs both classes");
-                assert_eq!(st.prop(by_id(doc, "t2"), "font-size").as_deref(), Some("9px"));
-            },
-        );
-    }
-
-    #[test]
-    fn descendant_matching_does_not_backtrack_combinatorially() {
-        // Many nested groups share class `a` and the first rule stacks eight descendant
-        // `.a` compounds under a leftmost class that matches nothing: an unmemoized
-        // matcher enumerates ancestor combinations for it and effectively never
-        // finishes (#1703). With suffix states memoized this returns at once, and the
-        // matching descendant and mixed child/descendant rules still apply.
-        let depth = 48;
-        let mut svg = String::from(
-            r#"<svg xmlns="http://www.w3.org/2000/svg"><style>
-            .missing .a .a .a .a .a .a .a .a text { fill: #111 }
-            .a .a .a text { fill: #222 }
-            .a > .a text { stroke: blue }
-            </style>"#,
-        );
-        for _ in 0..depth {
-            svg.push_str(r#"<g class="a">"#);
-        }
-        svg.push_str(r#"<text id="t">x</text>"#);
-        for _ in 0..depth {
-            svg.push_str("</g>");
-        }
-        svg.push_str("</svg>");
-        with_doc(&svg, |doc, st| {
-            let t = by_id(doc, "t");
-            assert_eq!(st.own(t, "fill").as_deref(), Some("#222"), "descendant rule matches, the .missing one does not");
-            assert_eq!(st.own(t, "stroke").as_deref(), Some("blue"), "mixed child/descendant rule matches");
-        });
-    }
-
-    #[test]
-    fn presentation_attributes_lose_to_rules() {
-        with_doc(
-            r#"<svg xmlns="http://www.w3.org/2000/svg"><style>#a { fill: blue }</style><text id="a" fill="red" stroke="red">x</text></svg>"#,
-            |doc, st| {
-                assert_eq!(st.own(by_id(doc, "a"), "fill").as_deref(), Some("blue"));
-                assert_eq!(st.own(by_id(doc, "a"), "stroke").as_deref(), Some("red"));
-            },
-        );
-    }
-
-    /// What [`Styles::declared`] gave before the rules were indexed: every rule tested against `n`.
-    fn declared_by_every_rule(st: &Styles, n: XNode) -> HashMap<String, String> {
-        type Key = (bool, bool, (u32, u32, u32), usize);
-        let mut best: HashMap<String, (Key, String)> = HashMap::new();
-        let mut put = |name: &str, value: &str, key: Key| {
-            if best.get(name).is_none_or(|(k, _)| key >= *k) {
-                best.insert(name.to_string(), (key, value.to_string()));
-            }
-        };
-        let mut order = 0;
-        for r in st.rules.iter().filter(|r| r.selector.matches(n)) {
-            for (k, v, imp) in r.decls.iter() {
-                order += 1;
-                put(k, v, (*imp, false, r.selector.specificity, order));
-            }
-        }
-        if let Some(s) = n.attribute("style") {
-            for (k, v, imp) in parse_decls(s) {
-                order += 1;
-                put(&k, &v, (imp, true, (0, 0, 0), order));
-            }
-        }
-        best.into_iter().map(|(k, (_, v))| (k, v)).collect()
-    }
-
-    /// Checks that each element of `svg` gets the properties [`declared_by_every_rule`] gives it.
-    fn assert_same_as_every_rule(svg: &str) {
-        let doc = roxmltree::Document::parse(svg).unwrap();
-        let st = Styles::new(&doc);
-        for n in doc.descendants().filter(|n| n.is_element()) {
-            assert_eq!(*st.declared(n), declared_by_every_rule(&st, n), "{n:?} in {svg}");
-        }
-    }
-
-    /// Id, class, type, universal and attribute selectors, descendant and child combinators, and
-    /// rules that override each other give each element what testing every rule gives it.
-    #[test]
-    fn indexed_rules_give_what_testing_every_rule_gives() {
-        let svg = r#"<svg xmlns="http://www.w3.org/2000/svg"><style>
-            * { stroke: s0 }
-            g rect { fill: f1 }
-            #a { fill: f2 }
-            .a { fill: f3 }
-            rect.a { fill: f4 }
-            .b.a { stroke: s5 }
-            g > .c { fill: f6 }
-            svg > g g rect { font-size: 9px }
-            [data-k=v] { display: none }
-            #a > tspan, text .x { font-size: 8px }
-            .c { fill: f8 !important }
-            rect { fill: f9 }
-            .a { fill: f10 }
-            [data-k] { fill: f11 }
-            </style>
-            <g class="c">
-              <rect id="a" class="a"/>
-              <rect id="r2" class="b&#9;a&#10;a"/>
-              <g class="c x"><rect id="r3" class="c" data-k="v"/><rect id="r4"/></g>
-              <circle id="c5" class="a x" data-k="w" style="stroke: s !important"/>
-            </g>
-            <text id="a" class="a"><tspan id="t6" class="x">t</tspan><tspan id="t7">u</tspan></text>
-            <rect id="r8" class="z"/>
-            </svg>"#;
-        assert_same_as_every_rule(svg);
-        with_doc(svg, |doc, st| {
-            let own = |id: &str, name: &str| st.own(by_id(doc, id), name);
-            assert_eq!(own("a", "fill").as_deref(), Some("f2"), "#a beats rect.a");
-            assert_eq!(own("r2", "fill").as_deref(), Some("f4"), "rect.a beats g rect");
-            assert_eq!(own("r2", "stroke").as_deref(), Some("s5"), "classes apart by a tab and a line feed, one repeated");
-            assert_eq!(own("r3", "fill").as_deref(), Some("f8"), "!important");
-            assert_eq!(own("r3", "display").as_deref(), Some("none"));
-            assert_eq!(own("r4", "fill").as_deref(), Some("f1"), "g rect beats rect");
-            assert_eq!(own("r4", "font-size").as_deref(), Some("9px"));
-            assert_eq!(own("c5", "fill").as_deref(), Some("f11"), "of rules alike, the last one");
-            assert_eq!(own("c5", "stroke").as_deref(), Some("s"));
-            assert_eq!(own("t7", "font-size").as_deref(), Some("8px"));
-            assert_eq!(own("r8", "fill").as_deref(), Some("f9"));
-        });
-    }
-
-    /// An element's candidates hold each rule once, however often the element repeats a class.
-    #[test]
-    fn repeated_classes_give_each_rule_once() {
-        with_doc(
-            r#"<svg xmlns="http://www.w3.org/2000/svg"><style>.a { fill: x } .b { stroke: y } .a.b { opacity: 0.5 } rect { fill: z }</style><rect id="r" class="a a b a b"/></svg>"#,
-            |doc, st| assert_eq!(st.index.candidates(by_id(doc, "r")), [0, 1, 2, 3]),
-        );
-    }
-
-    /// A compound selector over a few tags, ids, classes and attributes.
-    fn arb_compound() -> impl Strategy<Value = String> {
-        let tag = prop::sample::select(vec!["", "*", "g", "rect", "text", "tspan"]);
-        let id = prop::sample::select(vec!["", "#a", "#b"]);
-        let classes = prop::collection::vec(prop::sample::select(vec![".a", ".b", ".c"]), 0..3);
-        let attr = prop::sample::select(vec!["", "[data-k]", "[data-k=v]"]);
-        (tag, id, classes, attr).prop_map(|(t, i, c, a)| match format!("{t}{i}{}{a}", c.concat()) {
-            s if s.is_empty() => "*".to_string(),
-            s => s,
-        })
-    }
-
-    /// One to three compounds joined by descendant and child combinators.
-    fn arb_selector() -> impl Strategy<Value = String> {
-        (arb_compound(), prop::collection::vec((prop::sample::select(vec![" ", " > ", ">"]), arb_compound()), 0..3))
-            .prop_map(|(first, rest)| rest.into_iter().fold(first, |s, (comb, c)| format!("{s}{comb}{c}")))
-    }
-
-    /// A rule of one or two selectors that sets one to three properties, some of them `!important`.
-    fn arb_rule() -> impl Strategy<Value = String> {
-        let decl = (prop::sample::select(vec!["fill", "stroke", "display"]), 0..1000u16, any::<bool>())
-            .prop_map(|(name, v, important)| format!("{name}: v{v}{}", if important { " !important" } else { "" }));
-        (prop::collection::vec(arb_selector(), 1..3), prop::collection::vec(decl, 1..4))
-            .prop_map(|(selectors, decls)| format!("{} {{ {} }}", selectors.join(", "), decls.join("; ")))
-    }
-
-    /// An element that may have an id, classes (some repeated, apart by spaces, tabs and line feeds)
-    /// and a `data-k` or `style` attribute, with up to four children on each of the `depth` levels
-    /// below it.
-    fn arb_element(depth: u32) -> BoxedStrategy<String> {
-        let tag = prop::sample::select(vec!["g", "rect", "text", "tspan"]);
-        let id = prop::sample::select(vec!["", r#" id="a""#, r#" id="b""#, r#" id="c""#]);
-        let classes = prop::collection::vec((prop::sample::select(vec![" ", "&#9;", "&#10;"]), prop::sample::select(vec!["a", "b", "c", "x"])), 0..4)
-            .prop_map(|v| match v.iter().map(|(gap, c)| format!("{gap}{c}")).collect::<String>() {
-                s if s.is_empty() => s,
-                s => format!(r#" class="{s}""#),
-            });
-        let more = prop::sample::select(vec!["", r#" data-k="v""#, r#" data-k="w""#, r#" style="fill: s""#, r#" style="stroke: s !important""#]);
-        let children = if depth == 0 { Just(vec![]).boxed() } else { prop::collection::vec(arb_element(depth - 1), 0..5).boxed() };
-        (tag, id, classes, more, children).prop_map(|(t, i, c, m, ch)| format!("<{t}{i}{c}{m}>{}</{t}>", ch.concat())).boxed()
-    }
-
-    proptest! {
-        #![proptest_config(ProptestConfig { failure_persistence: None, ..ProptestConfig::default() })]
-
-        /// Random style sheets give each element of a random document what testing every rule
-        /// gives it.
-        #[test]
-        fn random_sheets_give_what_testing_every_rule_gives(rules in prop::collection::vec(arb_rule(), 0..24), body in prop::collection::vec(arb_element(3), 1..6)) {
-            assert_same_as_every_rule(&format!(r#"<svg xmlns="http://www.w3.org/2000/svg"><style>{}</style>{}</svg>"#, rules.join("\n"), body.concat()));
-        }
-    }
-
-    /// 50,000 class rules give 50,000 elements, each with one of the classes, their fill within
-    /// 20 s.
-    #[test]
-    fn styling_50000_elements_with_50000_rules_finishes_within_20_s() {
-        const N: usize = 50_000;
-        let rules: String = (0..N).map(|i| format!(".c{i} {{ fill: #{i:06x} }}\n")).collect();
-        let rects: String = (0..N).map(|i| format!(r#"<rect class="c{i}"/>"#)).collect();
-        let svg = format!(r#"<svg xmlns="http://www.w3.org/2000/svg"><style>{rules}</style>{rects}</svg>"#);
-        let (tx, rx) = std::sync::mpsc::channel();
-        std::thread::spawn(move || {
-            let doc = roxmltree::Document::parse(&svg).unwrap();
-            let st = Styles::new(&doc);
-            let fills: Vec<Option<String>> = doc.descendants().filter(|n| n.tag_name().name() == "rect").map(|n| st.own(n, "fill")).collect();
-            tx.send(fills).ok();
-        });
-        let fills = rx.recv_timeout(std::time::Duration::from_secs(20)).unwrap_or_else(|_| panic!("styling {N} elements did not finish within 20 s"));
-        assert_eq!(fills.len(), N);
-        for (i, fill) in fills.iter().enumerate() {
-            assert_eq!(fill.as_deref(), Some(format!("#{i:06x}").as_str()));
-        }
-    }
-
-    #[test]
-    fn the_font_shorthand_sets_its_longhands() {
-        let d = parse_decls("fill: red; font: italic bold 30px 'DejaVu Sans' ; font-weight: 300 !important; font: nonsense");
-        let get = |k: &str| d.iter().filter(|(n, ..)| n == k).map(|(_, v, i)| (v.as_str(), *i)).collect::<Vec<_>>();
-        assert_eq!(get("font-style"), [("italic", false)]);
-        assert_eq!(get("font-weight"), [("bold", false), ("300", true)]);
-        assert_eq!(get("font-size"), [("30px", false)]);
-        assert_eq!(get("font-family"), [("'DejaVu Sans'", false)]);
-        assert_eq!(get("font-variant"), [("normal", false)]);
-        assert_eq!(get("fill"), [("red", false)]);
-        assert!(get("font").is_empty(), "the shorthand itself is not kept");
-    }
-
-    #[test]
-    fn unsupported_selectors_are_dropped() {
-        for s in ["a + b", "a ~ b", "a:hover", "svg|text", "> a", "a >", "", "a:not(b c)", "a:not(.x", "a:not(b > c)", "a:not(:hover)"] {
-            assert!(Selector::parse(s).is_none(), "{s}");
-        }
-        let s = Selector::parse("g  >  text.x#y").unwrap();
-        assert_eq!(s.specificity, (1, 1, 2));
-        assert_eq!(s.parts.len(), 2);
-        assert!(s.parts[0].1, "text must be a child of g");
-    }
-
-    /// #1557: `:not()` of a list of compound selectors; it counts as its most specific argument.
-    #[test]
-    fn not_selectors() {
-        assert_eq!(Selector::parse("rect:not(.keep)").unwrap().specificity, (0, 1, 1));
-        assert_eq!(Selector::parse("g :not(#a, .b.c, text)").unwrap().specificity, (1, 0, 1));
-        assert_eq!(Selector::parse(":not(rect):not([x])").unwrap().specificity, (0, 1, 1));
-        // Nesting is bounded: a hostile sheet can't recurse without end.
-        let nested = |n: usize| format!("{}.x{}", ":not(".repeat(n), ")".repeat(n));
-        assert!(Selector::parse(&nested(MAX_NOT_NESTING)).is_some());
-        assert!(Selector::parse(&nested(MAX_NOT_NESTING + 1)).is_none());
-        assert!(Selector::parse(&nested(200_000)).is_none());
-        with_doc(
-            r#"<svg xmlns="http://www.w3.org/2000/svg"><style>
-            rect:not(.keep) { fill: green }
-            g > :not(rect, #t1) { stroke: blue }
-            :not(:not(.both)) { opacity: 0.5 }
-            .keep { fill: red }
-            </style>
-            <rect id="r0" fill="red"/><rect id="r1" class="keep"/>
-            <g><text id="t0">x</text><text id="t1">x</text><rect id="r2" class="both"/></g>
-            </svg>"#,
-            |doc, st| {
-                assert_eq!(st.own(by_id(doc, "r0"), "fill").as_deref(), Some("green"));
-                assert_eq!(st.own(by_id(doc, "r1"), "fill").as_deref(), Some("red"));
-                assert_eq!(st.own(by_id(doc, "t0"), "stroke").as_deref(), Some("blue"));
-                assert_eq!(st.own(by_id(doc, "t1"), "stroke"), None);
-                assert_eq!(st.own(by_id(doc, "r2"), "stroke"), None);
-                assert_eq!(st.own(by_id(doc, "r2"), "opacity").as_deref(), Some("0.5"));
-                assert_eq!(st.own(by_id(doc, "r0"), "opacity"), None);
-                assert!(st.has_not_rules());
-                assert_eq!(st.set_by_not_rules(by_id(doc, "r0")), [("fill".to_string(), "green".to_string())]);
-                assert!(st.set_by_not_rules(by_id(doc, "r1")).is_empty());
-            },
-        );
-    }
-}
+mod tests;
diff --git a/crates/svg/src/import/css/tests.rs b/crates/svg/src/import/css/tests.rs
new file mode 100644
index 000000000..89b519858
--- /dev/null
+++ b/crates/svg/src/import/css/tests.rs
@@ -0,0 +1,332 @@
+use proptest::prelude::*;
+
+use super::*;
+
+#[test]
+fn important_flag_is_case_insensitive() {
+    for s in ["fill: red !IMPORTANT", "fill: red !Important", "fill: red ! important"] {
+        assert_eq!(parse_decls(s), [("fill".to_string(), "red".to_string(), true)], "{s}");
+    }
+    assert_eq!(parse_decls("fill: red !importantx"), [("fill".to_string(), "red !importantx".to_string(), false)]);
+}
+
+#[test]
+fn semicolons_in_quotes_and_parens_do_not_split() {
+    let d = |k: &str, v: &str| (k.to_string(), v.to_string(), false);
+    assert_eq!(parse_decls("font-family:'A;B'; fill:red"), [d("font-family", "'A;B'"), d("fill", "red")]);
+    assert_eq!(parse_decls("font-family:\"A;B\"; fill:red"), [d("font-family", "\"A;B\""), d("fill", "red")]);
+    assert_eq!(
+        parse_decls("fill:url(data:image/svg+xml;base64,AAA); stroke:red"),
+        [d("fill", "url(data:image/svg+xml;base64,AAA)"), d("stroke", "red")]
+    );
+    let _ = parse_decls("font-family:'A;B; fill:red");
+}
+
+fn with_doc(svg: &str, f: impl FnOnce(&roxmltree::Document, &Styles)) {
+    let doc = roxmltree::Document::parse(svg).unwrap();
+    let st = Styles::new(&doc);
+    f(&doc, &st);
+}
+
+fn by_id<'a, 'i>(doc: &'a roxmltree::Document<'i>, id: &str) -> XNode<'a, 'i> {
+    doc.descendants().find(|n| n.attribute("id") == Some(id)).unwrap()
+}
+
+#[test]
+fn selectors_and_precedence() {
+    with_doc(
+        r#"<svg xmlns="http://www.w3.org/2000/svg"><style>
+            /* comment { fill: red } */
+            @media print { text { fill: red } }
+            @import url(x.css);
+            text { fill: #111; font-size: 9px }
+            g text { fill: #222 }
+            g > text.a { fill: #333 }
+            .a.b { stroke: blue }
+            #t2 { fill: #444 }
+            [data-k=v] { font-weight: bold }
+            text:first-child, text ~ text { fill: red }
+            .imp { fill: #555 !important }
+            </style>
+            <text id="t0">x</text>
+            <g><text id="t1" class="a b" fill="green">x</text>
+               <g><text id="t2" class="a" style="fill:#666">x</text></g>
+               <text id="t3" class="a imp" style="fill:#777" data-k="v">x</text></g>
+            </svg>"#,
+        |doc, st| {
+            assert_eq!(st.own(by_id(doc, "t0"), "fill").as_deref(), Some("#111"));
+            assert_eq!(st.own(by_id(doc, "t1"), "fill").as_deref(), Some("#333"), "child + class beats descendant");
+            assert_eq!(st.own(by_id(doc, "t1"), "stroke").as_deref(), Some("blue"), "multiple classes");
+            assert_eq!(st.own(by_id(doc, "t2"), "fill").as_deref(), Some("#666"), "style attribute beats #id");
+            assert_eq!(st.own(by_id(doc, "t3"), "fill").as_deref(), Some("#555"), "!important beats style");
+            assert_eq!(st.own(by_id(doc, "t3"), "font-weight").as_deref(), Some("bold"));
+            assert_eq!(st.own(by_id(doc, "t2"), "stroke"), None, "`.a.b` needs both classes");
+            assert_eq!(st.prop(by_id(doc, "t2"), "font-size").as_deref(), Some("9px"));
+        },
+    );
+}
+
+#[test]
+fn descendant_matching_does_not_backtrack_combinatorially() {
+    // Many nested groups share class `a` and the first rule stacks eight descendant
+    // `.a` compounds under a leftmost class that matches nothing: an unmemoized
+    // matcher enumerates ancestor combinations for it and effectively never
+    // finishes (#1703). With suffix states memoized this returns at once, and the
+    // matching descendant and mixed child/descendant rules still apply.
+    let depth = 48;
+    let mut svg = String::from(
+        r#"<svg xmlns="http://www.w3.org/2000/svg"><style>
+            .missing .a .a .a .a .a .a .a .a text { fill: #111 }
+            .a .a .a text { fill: #222 }
+            .a > .a text { stroke: blue }
+            </style>"#,
+    );
+    for _ in 0..depth {
+        svg.push_str(r#"<g class="a">"#);
+    }
+    svg.push_str(r#"<text id="t">x</text>"#);
+    for _ in 0..depth {
+        svg.push_str("</g>");
+    }
+    svg.push_str("</svg>");
+    with_doc(&svg, |doc, st| {
+        let t = by_id(doc, "t");
+        assert_eq!(st.own(t, "fill").as_deref(), Some("#222"), "descendant rule matches, the .missing one does not");
+        assert_eq!(st.own(t, "stroke").as_deref(), Some("blue"), "mixed child/descendant rule matches");
+    });
+}
+
+#[test]
+fn presentation_attributes_lose_to_rules() {
+    with_doc(
+        r#"<svg xmlns="http://www.w3.org/2000/svg"><style>#a { fill: blue }</style><text id="a" fill="red" stroke="red">x</text></svg>"#,
+        |doc, st| {
+            assert_eq!(st.own(by_id(doc, "a"), "fill").as_deref(), Some("blue"));
+            assert_eq!(st.own(by_id(doc, "a"), "stroke").as_deref(), Some("red"));
+        },
+    );
+}
+
+/// What [`Styles::declared`] gave before the rules were indexed: every rule tested against `n`.
+fn declared_by_every_rule(st: &Styles, n: XNode) -> HashMap<String, String> {
+    type Key = (bool, bool, (u32, u32, u32), usize);
+    let mut best: HashMap<String, (Key, String)> = HashMap::new();
+    let mut put = |name: &str, value: &str, key: Key| {
+        if best.get(name).is_none_or(|(k, _)| key >= *k) {
+            best.insert(name.to_string(), (key, value.to_string()));
+        }
+    };
+    let mut order = 0;
+    for r in st.rules.iter().filter(|r| r.selector.matches(n)) {
+        for (k, v, imp) in r.decls.iter() {
+            order += 1;
+            put(k, v, (*imp, false, r.selector.specificity, order));
+        }
+    }
+    if let Some(s) = n.attribute("style") {
+        for (k, v, imp) in parse_decls(s) {
+            order += 1;
+            put(&k, &v, (imp, true, (0, 0, 0), order));
+        }
+    }
+    best.into_iter().map(|(k, (_, v))| (k, v)).collect()
+}
+
+/// Checks that each element of `svg` gets the properties [`declared_by_every_rule`] gives it.
+fn assert_same_as_every_rule(svg: &str) {
+    let doc = roxmltree::Document::parse(svg).unwrap();
+    let st = Styles::new(&doc);
+    for n in doc.descendants().filter(|n| n.is_element()) {
+        assert_eq!(*st.declared(n), declared_by_every_rule(&st, n), "{n:?} in {svg}");
+    }
+}
+
+/// Id, class, type, universal and attribute selectors, descendant and child combinators, and
+/// rules that override each other give each element what testing every rule gives it.
+#[test]
+fn indexed_rules_give_what_testing_every_rule_gives() {
+    let svg = r#"<svg xmlns="http://www.w3.org/2000/svg"><style>
+            * { stroke: s0 }
+            g rect { fill: f1 }
+            #a { fill: f2 }
+            .a { fill: f3 }
+            rect.a { fill: f4 }
+            .b.a { stroke: s5 }
+            g > .c { fill: f6 }
+            svg > g g rect { font-size: 9px }
+            [data-k=v] { display: none }
+            #a > tspan, text .x { font-size: 8px }
+            .c { fill: f8 !important }
+            rect { fill: f9 }
+            .a { fill: f10 }
+            [data-k] { fill: f11 }
+            </style>
+            <g class="c">
+              <rect id="a" class="a"/>
+              <rect id="r2" class="b&#9;a&#10;a"/>
+              <g class="c x"><rect id="r3" class="c" data-k="v"/><rect id="r4"/></g>
+              <circle id="c5" class="a x" data-k="w" style="stroke: s !important"/>
+            </g>
+            <text id="a" class="a"><tspan id="t6" class="x">t</tspan><tspan id="t7">u</tspan></text>
+            <rect id="r8" class="z"/>
+            </svg>"#;
+    assert_same_as_every_rule(svg);
+    with_doc(svg, |doc, st| {
+        let own = |id: &str, name: &str| st.own(by_id(doc, id), name);
+        assert_eq!(own("a", "fill").as_deref(), Some("f2"), "#a beats rect.a");
+        assert_eq!(own("r2", "fill").as_deref(), Some("f4"), "rect.a beats g rect");
+        assert_eq!(own("r2", "stroke").as_deref(), Some("s5"), "classes apart by a tab and a line feed, one repeated");
+        assert_eq!(own("r3", "fill").as_deref(), Some("f8"), "!important");
+        assert_eq!(own("r3", "display").as_deref(), Some("none"));
+        assert_eq!(own("r4", "fill").as_deref(), Some("f1"), "g rect beats rect");
+        assert_eq!(own("r4", "font-size").as_deref(), Some("9px"));
+        assert_eq!(own("c5", "fill").as_deref(), Some("f11"), "of rules alike, the last one");
+        assert_eq!(own("c5", "stroke").as_deref(), Some("s"));
+        assert_eq!(own("t7", "font-size").as_deref(), Some("8px"));
+        assert_eq!(own("r8", "fill").as_deref(), Some("f9"));
+    });
+}
+
+/// An element's candidates hold each rule once, however often the element repeats a class.
+#[test]
+fn repeated_classes_give_each_rule_once() {
+    with_doc(
+        r#"<svg xmlns="http://www.w3.org/2000/svg"><style>.a { fill: x } .b { stroke: y } .a.b { opacity: 0.5 } rect { fill: z }</style><rect id="r" class="a a b a b"/></svg>"#,
+        |doc, st| assert_eq!(st.index.candidates(by_id(doc, "r")), [0, 1, 2, 3]),
+    );
+}
+
+/// A compound selector over a few tags, ids, classes and attributes.
+fn arb_compound() -> impl Strategy<Value = String> {
+    let tag = prop::sample::select(vec!["", "*", "g", "rect", "text", "tspan"]);
+    let id = prop::sample::select(vec!["", "#a", "#b"]);
+    let classes = prop::collection::vec(prop::sample::select(vec![".a", ".b", ".c"]), 0..3);
+    let attr = prop::sample::select(vec!["", "[data-k]", "[data-k=v]"]);
+    (tag, id, classes, attr).prop_map(|(t, i, c, a)| match format!("{t}{i}{}{a}", c.concat()) {
+        s if s.is_empty() => "*".to_string(),
+        s => s,
+    })
+}
+
+/// One to three compounds joined by descendant and child combinators.
+fn arb_selector() -> impl Strategy<Value = String> {
+    (arb_compound(), prop::collection::vec((prop::sample::select(vec![" ", " > ", ">"]), arb_compound()), 0..3))
+        .prop_map(|(first, rest)| rest.into_iter().fold(first, |s, (comb, c)| format!("{s}{comb}{c}")))
+}
+
+/// A rule of one or two selectors that sets one to three properties, some of them `!important`.
+fn arb_rule() -> impl Strategy<Value = String> {
+    let decl = (prop::sample::select(vec!["fill", "stroke", "display"]), 0..1000u16, any::<bool>())
+        .prop_map(|(name, v, important)| format!("{name}: v{v}{}", if important { " !important" } else { "" }));
+    (prop::collection::vec(arb_selector(), 1..3), prop::collection::vec(decl, 1..4))
+        .prop_map(|(selectors, decls)| format!("{} {{ {} }}", selectors.join(", "), decls.join("; ")))
+}
+
+/// An element that may have an id, classes (some repeated, apart by spaces, tabs and line feeds)
+/// and a `data-k` or `style` attribute, with up to four children on each of the `depth` levels
+/// below it.
+fn arb_element(depth: u32) -> BoxedStrategy<String> {
+    let tag = prop::sample::select(vec!["g", "rect", "text", "tspan"]);
+    let id = prop::sample::select(vec!["", r#" id="a""#, r#" id="b""#, r#" id="c""#]);
+    let classes = prop::collection::vec((prop::sample::select(vec![" ", "&#9;", "&#10;"]), prop::sample::select(vec!["a", "b", "c", "x"])), 0..4)
+        .prop_map(|v| match v.iter().map(|(gap, c)| format!("{gap}{c}")).collect::<String>() {
+            s if s.is_empty() => s,
+            s => format!(r#" class="{s}""#),
+        });
+    let more = prop::sample::select(vec!["", r#" data-k="v""#, r#" data-k="w""#, r#" style="fill: s""#, r#" style="stroke: s !important""#]);
+    let children = if depth == 0 { Just(vec![]).boxed() } else { prop::collection::vec(arb_element(depth - 1), 0..5).boxed() };
+    (tag, id, classes, more, children).prop_map(|(t, i, c, m, ch)| format!("<{t}{i}{c}{m}>{}</{t}>", ch.concat())).boxed()
+}
+
+proptest! {
+    #![proptest_config(ProptestConfig { failure_persistence: None, ..ProptestConfig::default() })]
+
+    /// Random style sheets give each element of a random document what testing every rule
+    /// gives it.
+    #[test]
+    fn random_sheets_give_what_testing_every_rule_gives(rules in prop::collection::vec(arb_rule(), 0..24), body in prop::collection::vec(arb_element(3), 1..6)) {
+        assert_same_as_every_rule(&format!(r#"<svg xmlns="http://www.w3.org/2000/svg"><style>{}</style>{}</svg>"#, rules.join("\n"), body.concat()));
+    }
+}
+
+/// 50,000 class rules give 50,000 elements, each with one of the classes, their fill within
+/// 20 s.
+#[test]
+fn styling_50000_elements_with_50000_rules_finishes_within_20_s() {
+    const N: usize = 50_000;
+    let rules: String = (0..N).map(|i| format!(".c{i} {{ fill: #{i:06x} }}\n")).collect();
+    let rects: String = (0..N).map(|i| format!(r#"<rect class="c{i}"/>"#)).collect();
+    let svg = format!(r#"<svg xmlns="http://www.w3.org/2000/svg"><style>{rules}</style>{rects}</svg>"#);
+    let (tx, rx) = std::sync::mpsc::channel();
+    std::thread::spawn(move || {
+        let doc = roxmltree::Document::parse(&svg).unwrap();
+        let st = Styles::new(&doc);
+        let fills: Vec<Option<String>> = doc.descendants().filter(|n| n.tag_name().name() == "rect").map(|n| st.own(n, "fill")).collect();
+        tx.send(fills).ok();
+    });
+    let fills = rx.recv_timeout(std::time::Duration::from_secs(20)).unwrap_or_else(|_| panic!("styling {N} elements did not finish within 20 s"));
+    assert_eq!(fills.len(), N);
+    for (i, fill) in fills.iter().enumerate() {
+        assert_eq!(fill.as_deref(), Some(format!("#{i:06x}").as_str()));
+    }
+}
+
+#[test]
+fn the_font_shorthand_sets_its_longhands() {
+    let d = parse_decls("fill: red; font: italic bold 30px 'DejaVu Sans' ; font-weight: 300 !important; font: nonsense");
+    let get = |k: &str| d.iter().filter(|(n, ..)| n == k).map(|(_, v, i)| (v.as_str(), *i)).collect::<Vec<_>>();
+    assert_eq!(get("font-style"), [("italic", false)]);
+    assert_eq!(get("font-weight"), [("bold", false), ("300", true)]);
+    assert_eq!(get("font-size"), [("30px", false)]);
+    assert_eq!(get("font-family"), [("'DejaVu Sans'", false)]);
+    assert_eq!(get("font-variant"), [("normal", false)]);
+    assert_eq!(get("fill"), [("red", false)]);
+    assert!(get("font").is_empty(), "the shorthand itself is not kept");
+}
+
+#[test]
+fn unsupported_selectors_are_dropped() {
+    for s in ["a + b", "a ~ b", "a:hover", "svg|text", "> a", "a >", "", "a:not(b c)", "a:not(.x", "a:not(b > c)", "a:not(:hover)"] {
+        assert!(Selector::parse(s).is_none(), "{s}");
+    }
+    let s = Selector::parse("g  >  text.x#y").unwrap();
+    assert_eq!(s.specificity, (1, 1, 2));
+    assert_eq!(s.parts.len(), 2);
+    assert!(s.parts[0].1, "text must be a child of g");
+}
+
+/// #1557: `:not()` of a list of compound selectors; it counts as its most specific argument.
+#[test]
+fn not_selectors() {
+    assert_eq!(Selector::parse("rect:not(.keep)").unwrap().specificity, (0, 1, 1));
+    assert_eq!(Selector::parse("g :not(#a, .b.c, text)").unwrap().specificity, (1, 0, 1));
+    assert_eq!(Selector::parse(":not(rect):not([x])").unwrap().specificity, (0, 1, 1));
+    // Nesting is bounded: a hostile sheet can't recurse without end.
+    let nested = |n: usize| format!("{}.x{}", ":not(".repeat(n), ")".repeat(n));
+    assert!(Selector::parse(&nested(MAX_NOT_NESTING)).is_some());
+    assert!(Selector::parse(&nested(MAX_NOT_NESTING + 1)).is_none());
+    assert!(Selector::parse(&nested(200_000)).is_none());
+    with_doc(
+        r#"<svg xmlns="http://www.w3.org/2000/svg"><style>
+            rect:not(.keep) { fill: green }
+            g > :not(rect, #t1) { stroke: blue }
+            :not(:not(.both)) { opacity: 0.5 }
+            .keep { fill: red }
+            </style>
+            <rect id="r0" fill="red"/><rect id="r1" class="keep"/>
+            <g><text id="t0">x</text><text id="t1">x</text><rect id="r2" class="both"/></g>
+            </svg>"#,
+        |doc, st| {
+            assert_eq!(st.own(by_id(doc, "r0"), "fill").as_deref(), Some("green"));
+            assert_eq!(st.own(by_id(doc, "r1"), "fill").as_deref(), Some("red"));
+            assert_eq!(st.own(by_id(doc, "t0"), "stroke").as_deref(), Some("blue"));
+            assert_eq!(st.own(by_id(doc, "t1"), "stroke"), None);
+            assert_eq!(st.own(by_id(doc, "r2"), "stroke"), None);
+            assert_eq!(st.own(by_id(doc, "r2"), "opacity").as_deref(), Some("0.5"));
+            assert_eq!(st.own(by_id(doc, "r0"), "opacity"), None);
+            assert!(st.has_not_rules());
+            assert_eq!(st.set_by_not_rules(by_id(doc, "r0")), [("fill".to_string(), "green".to_string())]);
+            assert!(st.set_by_not_rules(by_id(doc, "r1")).is_empty());
+        },
+    );
+}