Hello
", + "Hello
", ); assert!(doc.doctype.is_some()); assert_eq!(doc.doctype.as_ref().unwrap().name, "html"); @@ -518,4 +482,424 @@ mod tests { assert_eq!(div.get_attribute("id"), Some("main")); } } + + #[test] + fn test_pop_until_nested() { + let nodes = parse_fragment("Hello World
");
+ assert_eq!(nodes.len(), 1);
+ if let Some(Node::Element(div)) = nodes.first() {
+ assert_eq!(div.tag_name, "div");
+ assert_eq!(div.children.len(), 2);
+ if let Some(Node::Element(span)) = div.children.first() {
+ assert_eq!(span.tag_name, "span");
+ assert_eq!(span.text_content(), Some("Hello".into()));
+ }
+ }
+ }
+
+ #[test]
+ fn test_deeply_nested_fragment() {
+ let nodes = parse_fragment("- Deep
After
One
Two
Three
"); + assert_eq!(nodes.len(), 3); + } + + #[test] + fn test_many_children_fragment() { + use core::fmt::Write; + let mut html = String::from("");
+ for i in 0..1100 {
+ let _ = write!(html, "{i}");
+ }
+ html.push_str("
");
+ let nodes = parse_fragment(&html);
+ assert_eq!(nodes.len(), 1);
+ if let Some(Node::Element(div)) = nodes.first() {
+ assert_eq!(div.children.len(), 1100);
+ }
+ }
+
+ #[test]
+ fn test_unmatched_end_tag() {
+ // Unmatched should not crash or empty the stack
+ let nodes = parse_fragment("Hello
");
+ assert_eq!(nodes.len(), 1);
+ if let Some(Node::Element(div)) = nodes.first() {
+ assert_eq!(div.tag_name, "div");
+ }
+ }
+
+ // ── pop_until tests ──────────────────────────────────────────────
+
+ #[test]
+ fn test_pop_until_skips_intermediate() {
+ // should pop both and , closing at
+ let nodes = parse_fragment("
+ // pops em, span, div
+ let span = div.find_element("span").unwrap();
+ let em = span.find_element("em").unwrap();
+ assert_eq!(em.text_content(), Some("Text".into()));
+ }
+
+ #[test]
+ fn test_pop_until_no_match_preserves_root() {
+ // pops elements but stops at root sentinel
+ let nodes = parse_fragment("Text
");
+ assert_eq!(nodes.len(), 1);
+ let div = nodes[0].as_element().unwrap();
+ assert_eq!(div.tag_name, "div");
+ // span was opened, em was opened inside span, then Hello
s: inner
should only close the inner one
+ let nodes = parse_fragment("Inner
OuterDeepMidTop
");
+ assert_eq!(nodes.len(), 1);
+ let div = nodes[0].as_element().unwrap();
+ let s1 = div.find_element("span").unwrap();
+ let s2 = s1.find_element("span").unwrap();
+ let s3 = s2.find_element("span").unwrap();
+ assert_eq!(s3.text_content(), Some("Deep".into()));
+ // "Mid" is text after inner span closes, inside middle span
+ assert!(s2.children.len() >= 2);
+ // "Top" is text after middle span closes, inside outer span
+ assert!(s1.children.len() >= 2);
+ }
+
+ // ── fragment nesting tests ───────────────────────────────────────
+
+ #[test]
+ fn test_fragment_five_levels_deep() {
+ let nodes = parse_fragment(
+ "ABCDE
");
+ assert_eq!(nodes.len(), 1);
+ let div = nodes[0].as_element().unwrap();
+ // div has: text("A"), span, text("E")
+ assert_eq!(div.children.len(), 3);
+ assert_eq!(div.children[0].as_text().unwrap().data, "A");
+ let span = div.children[1].as_element().unwrap();
+ // span has: text("B"), em, text("D")
+ assert_eq!(span.children.len(), 3);
+ assert_eq!(span.children[0].as_text().unwrap().data, "B");
+ let em = span.children[1].as_element().unwrap();
+ assert_eq!(em.text_content(), Some("C".into()));
+ assert_eq!(span.children[2].as_text().unwrap().data, "D");
+ assert_eq!(div.children[2].as_text().unwrap().data, "E");
+ }
+
+ #[test]
+ fn test_fragment_siblings_with_children() {
+ let nodes = parse_fragment("- One!
- Two
- Three
Before
After
Hi
");
+ assert_eq!(nodes.len(), 2);
+ assert!(matches!(nodes[0], Node::Comment(_)));
+ if let Node::Comment(c) = &nodes[0] {
+ assert_eq!(c.data, " top ");
+ }
+ assert_eq!(nodes[1].as_element().unwrap().tag_name, "div");
+ }
+
+ #[test]
+ fn test_fragment_comment_inside_element() {
+ let nodes = parse_fragment("");
+ assert_eq!(nodes.len(), 1);
+ let div = nodes[0].as_element().unwrap();
+ assert_eq!(div.children.len(), 1);
+ assert!(matches!(div.children[0], Node::Comment(_)));
+ }
+
+ #[test]
+ fn test_fragment_comment_between_elements() {
+ let nodes = parse_fragment("- A
- B
Hello
");
+ assert_eq!(nodes.len(), 1);
+ let div = nodes[0].as_element().unwrap();
+ assert_eq!(div.text_content(), Some("Hello".into()));
+ }
+
+ #[test]
+ fn test_malformed_unclosed_tags() {
+ // Tags that are never closed
+ let nodes = parse_fragment("Text");
+ assert_eq!(nodes.len(), 1);
+ let div = nodes[0].as_element().unwrap();
+ let span = div.find_element("span").unwrap();
+ let em = span.find_element("em").unwrap();
+ assert_eq!(em.text_content(), Some("Text".into()));
+ }
+
+ #[test]
+ fn test_malformed_interleaved_tags() {
+ // - interleaved close order
+ let nodes = parse_fragment("TextAfter");
+ // After pops both i and b (pop_until finds b).
+ // "After" goes to root since both are closed.
+ // is unmatched, ignored.
+ assert!(!nodes.is_empty());
+ let b = nodes[0].as_element().unwrap();
+ assert_eq!(b.tag_name, "b");
+ }
+
+ #[test]
+ fn test_malformed_deeply_mismatched() {
+ let nodes = parse_fragment("Text Test
+
+
+ "#,
+ );
+ let head = doc.head().unwrap();
+ assert!(head.find_element("title").is_some());
+ assert!(head.find_element("meta").is_some());
+ assert!(head.find_element("link").is_some());
+ }
+
+ #[test]
+ fn test_document_implicit_body() {
+ // No explicit tag, elements go into implicit body
+ let doc = parse("Hello World \
+ ",
+ );
+ assert_eq!(doc.title(), Some(String::from("Hello World")));
+ }
+
+ #[test]
+ fn test_document_round_trip() {
+ let html = "Test \
+
Content
");
+ let body = doc.body().unwrap();
+ let div = body.find_element("div").unwrap();
+ assert_eq!(div.text_content(), Some("Content".into()));
+ }
+
+ #[test]
+ fn test_document_implicit_head_and_body() {
+ // No head or body, just content
+ let doc = parse("Content
");
+ assert_eq!(doc.root.tag_name, "html");
+ assert!(doc.head().is_some());
+ assert!(doc.body().is_some());
+ let body = doc.body().unwrap();
+ let div = body.find_element("div").unwrap();
+ assert_eq!(div.text_content(), Some("Content".into()));
+ }
+
+ #[test]
+ fn test_document_title() {
+ let doc = parse(
+ "Hello
"; + let doc = parse(html); + let output = doc.to_html(); + // Re-parse the output and verify structure + let doc2 = parse(&output); + assert_eq!(doc2.title(), Some(String::from("Test"))); + let body = doc2.body().unwrap(); + let p = body.find_element("p").unwrap(); + assert_eq!(p.text_content(), Some("Hello".into())); + } }