aboutsummaryrefslogtreecommitdiffstats
path: root/src/mdast.rs
diff options
context:
space:
mode:
authorLibravatar Titus Wormer <tituswormer@gmail.com>2022-10-13 16:52:44 +0200
committerLibravatar Titus Wormer <tituswormer@gmail.com>2022-10-13 16:53:10 +0200
commite0ca78397ea34cde06ab8257a8481afc812d344f (patch)
tree5dc85ca4f9e18c2b93a3f86f106f2cd8535c828b /src/mdast.rs
parent5ad84c1670733843f677b2c5bee8c50d78b8e24a (diff)
downloadmarkdown-rs-e0ca78397ea34cde06ab8257a8481afc812d344f.tar.gz
markdown-rs-e0ca78397ea34cde06ab8257a8481afc812d344f.tar.bz2
markdown-rs-e0ca78397ea34cde06ab8257a8481afc812d344f.zip
Add a lot of tests on how mdast, unist work
Diffstat (limited to 'src/mdast.rs')
-rw-r--r--src/mdast.rs953
1 files changed, 917 insertions, 36 deletions
diff --git a/src/mdast.rs b/src/mdast.rs
index 5e3fca6..a7d887a 100644
--- a/src/mdast.rs
+++ b/src/mdast.rs
@@ -1151,44 +1151,925 @@ pub struct MdxJsxAttribute {
#[cfg(test)]
mod tests {
use super::*;
- use crate::unist::{Point, Position};
- use alloc::vec;
+ use crate::unist::Position;
+ use alloc::{format, string::ToString, vec};
+
+ // Literals.
+
+ #[test]
+ fn text() {
+ let mut node = Node::Text(Text {
+ value: "a".into(),
+ position: None,
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Text { value: \"a\", position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "a", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Text { value: \"a\", position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn inline_code() {
+ let mut node = Node::InlineCode(InlineCode {
+ value: "a".into(),
+ position: None,
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "InlineCode { value: \"a\", position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "a", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "InlineCode { value: \"a\", position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn code() {
+ let mut node = Node::Code(Code {
+ value: "a".into(),
+ position: None,
+ lang: None,
+ meta: None,
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Code { value: \"a\", position: None, lang: None, meta: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "a", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Code { value: \"a\", position: Some(1:1-1:2 (0-1)), lang: None, meta: None }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn inline_math() {
+ let mut node = Node::InlineMath(InlineMath {
+ value: "a".into(),
+ position: None,
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "InlineMath { value: \"a\", position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "a", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "InlineMath { value: \"a\", position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn math() {
+ let mut node = Node::Math(Math {
+ value: "a".into(),
+ position: None,
+ meta: None,
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Math { value: \"a\", position: None, meta: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "a", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Math { value: \"a\", position: Some(1:1-1:2 (0-1)), meta: None }",
+ "should support `position_set`"
+ );
+ }
#[test]
- fn test() {
- let text = Text {
+ fn html() {
+ let mut node = Node::Html(Html {
value: "a".into(),
- position: Some(Position {
- start: Point {
- line: 1,
- column: 1,
- offset: 0,
- },
- end: Point {
- line: 1,
- column: 2,
- offset: 1,
- },
- }),
- };
-
- let paragraph = Paragraph {
- children: vec![Node::Text(text)],
- position: Some(Position {
- start: Point {
- line: 1,
- column: 1,
- offset: 0,
- },
- end: Point {
- line: 1,
- column: 2,
- offset: 1,
- },
- }),
- };
-
- assert_eq!(paragraph.children.len(), 1);
- assert!(matches!(&paragraph.children[0], Node::Text(_)));
+ position: None,
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Html { value: \"a\", position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "a", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Html { value: \"a\", position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn mdx_text_expression() {
+ let mut node = Node::MdxTextExpression(MdxTextExpression {
+ value: "a".into(),
+ stops: vec![],
+ position: None,
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "MdxTextExpression { value: \"a\", position: None, stops: [] }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "a", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "MdxTextExpression { value: \"a\", position: Some(1:1-1:2 (0-1)), stops: [] }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn mdx_flow_expression() {
+ let mut node = Node::MdxFlowExpression(MdxFlowExpression {
+ value: "a".into(),
+ stops: vec![],
+ position: None,
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "MdxFlowExpression { value: \"a\", position: None, stops: [] }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "a", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "MdxFlowExpression { value: \"a\", position: Some(1:1-1:2 (0-1)), stops: [] }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn mdxjs_esm() {
+ let mut node = Node::MdxjsEsm(MdxjsEsm {
+ value: "a".into(),
+ stops: vec![],
+ position: None,
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "MdxjsEsm { value: \"a\", position: None, stops: [] }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "a", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "MdxjsEsm { value: \"a\", position: Some(1:1-1:2 (0-1)), stops: [] }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn toml() {
+ let mut node = Node::Toml(Toml {
+ value: "a".into(),
+ position: None,
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Toml { value: \"a\", position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "a", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Toml { value: \"a\", position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn yaml() {
+ let mut node = Node::Yaml(Yaml {
+ value: "a".into(),
+ position: None,
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Yaml { value: \"a\", position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "a", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Yaml { value: \"a\", position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ // Voids.
+
+ #[test]
+ fn break_node() {
+ let mut node = Node::Break(Break { position: None });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Break { position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Break { position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn thematic_break() {
+ let mut node = Node::ThematicBreak(ThematicBreak { position: None });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "ThematicBreak { position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "ThematicBreak { position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn footnote_reference() {
+ let mut node = Node::FootnoteReference(FootnoteReference {
+ position: None,
+ identifier: "a".into(),
+ label: Some("b".into()),
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "FootnoteReference { position: None, identifier: \"a\", label: Some(\"b\") }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "FootnoteReference { position: Some(1:1-1:2 (0-1)), identifier: \"a\", label: Some(\"b\") }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn image_reference() {
+ let mut node = Node::ImageReference(ImageReference {
+ position: None,
+ alt: "a".into(),
+ identifier: "b".into(),
+ label: Some("c".into()),
+ reference_kind: ReferenceKind::Full,
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "ImageReference { position: None, alt: \"a\", reference_kind: Full, identifier: \"b\", label: Some(\"c\") }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "ImageReference { position: Some(1:1-1:2 (0-1)), alt: \"a\", reference_kind: Full, identifier: \"b\", label: Some(\"c\") }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn image() {
+ let mut node = Node::Image(Image {
+ position: None,
+ alt: "a".into(),
+ url: "b".into(),
+ title: None,
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Image { position: None, alt: \"a\", url: \"b\", title: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Image { position: Some(1:1-1:2 (0-1)), alt: \"a\", url: \"b\", title: None }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn definition() {
+ let mut node = Node::Definition(Definition {
+ position: None,
+ identifier: "a".into(),
+ label: None,
+ url: "b".into(),
+ title: None,
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Definition { position: None, url: \"b\", title: None, identifier: \"a\", label: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(node.children_mut(), None, "should support `children_mut`");
+ assert_eq!(node.children(), None, "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Definition { position: Some(1:1-1:2 (0-1)), url: \"b\", title: None, identifier: \"a\", label: None }",
+ "should support `position_set`"
+ );
+ }
+
+ // Parents.
+
+ #[test]
+ fn root() {
+ let mut node = Node::Root(Root {
+ position: None,
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Root { children: [], position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Root { children: [], position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn block_quote() {
+ let mut node = Node::BlockQuote(BlockQuote {
+ position: None,
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "BlockQuote { children: [], position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "BlockQuote { children: [], position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn delete() {
+ let mut node = Node::Delete(Delete {
+ position: None,
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Delete { children: [], position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Delete { children: [], position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn emphasis() {
+ let mut node = Node::Emphasis(Emphasis {
+ position: None,
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Emphasis { children: [], position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Emphasis { children: [], position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn strong() {
+ let mut node = Node::Strong(Strong {
+ position: None,
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Strong { children: [], position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Strong { children: [], position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn paragraph() {
+ let mut node = Node::Paragraph(Paragraph {
+ position: None,
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Paragraph { children: [], position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Paragraph { children: [], position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn table_row() {
+ let mut node = Node::TableRow(TableRow {
+ position: None,
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "TableRow { children: [], position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "TableRow { children: [], position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn table_cell() {
+ let mut node = Node::TableCell(TableCell {
+ position: None,
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "TableCell { children: [], position: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "TableCell { children: [], position: Some(1:1-1:2 (0-1)) }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn heading() {
+ let mut node = Node::Heading(Heading {
+ position: None,
+ depth: 1,
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Heading { children: [], position: None, depth: 1 }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Heading { children: [], position: Some(1:1-1:2 (0-1)), depth: 1 }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn table() {
+ let mut node = Node::Table(Table {
+ position: None,
+ align: vec![],
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Table { children: [], position: None, align: [] }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Table { children: [], position: Some(1:1-1:2 (0-1)), align: [] }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn list_item() {
+ let mut node = Node::ListItem(ListItem {
+ position: None,
+ spread: false,
+ checked: None,
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "ListItem { children: [], position: None, spread: false, checked: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "ListItem { children: [], position: Some(1:1-1:2 (0-1)), spread: false, checked: None }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn list() {
+ let mut node = Node::List(List {
+ position: None,
+ spread: false,
+ ordered: false,
+ start: None,
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "List { children: [], position: None, ordered: false, start: None, spread: false }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "List { children: [], position: Some(1:1-1:2 (0-1)), ordered: false, start: None, spread: false }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn link() {
+ let mut node = Node::Link(Link {
+ position: None,
+ url: "a".into(),
+ title: None,
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "Link { children: [], position: None, url: \"a\", title: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "Link { children: [], position: Some(1:1-1:2 (0-1)), url: \"a\", title: None }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn footnote_definition() {
+ let mut node = Node::FootnoteDefinition(FootnoteDefinition {
+ position: None,
+ identifier: "a".into(),
+ label: None,
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "FootnoteDefinition { children: [], position: None, identifier: \"a\", label: None }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "FootnoteDefinition { children: [], position: Some(1:1-1:2 (0-1)), identifier: \"a\", label: None }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn mdx_jsx_flow_element() {
+ let mut node = Node::MdxJsxFlowElement(MdxJsxFlowElement {
+ position: None,
+ name: None,
+ attributes: vec![],
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "MdxJsxFlowElement { children: [], position: None, name: None, attributes: [] }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "MdxJsxFlowElement { children: [], position: Some(1:1-1:2 (0-1)), name: None, attributes: [] }",
+ "should support `position_set`"
+ );
+ }
+
+ #[test]
+ fn mdx_jsx_text_element() {
+ let mut node = Node::MdxJsxTextElement(MdxJsxTextElement {
+ position: None,
+ name: None,
+ attributes: vec![],
+ children: vec![],
+ });
+
+ assert_eq!(
+ format!("{:?}", node),
+ "MdxJsxTextElement { children: [], position: None, name: None, attributes: [] }",
+ "should support `Debug`"
+ );
+ assert_eq!(node.to_string(), "", "should support `ToString`");
+ assert_eq!(
+ node.children_mut(),
+ Some(&mut vec![]),
+ "should support `children_mut`"
+ );
+ assert_eq!(node.children(), Some(&vec![]), "should support `children`");
+ assert_eq!(node.position(), None, "should support `position`");
+ assert_eq!(node.position_mut(), None, "should support `position`");
+ node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
+ assert_eq!(
+ format!("{:?}", node),
+ "MdxJsxTextElement { children: [], position: Some(1:1-1:2 (0-1)), name: None, attributes: [] }",
+ "should support `position_set`"
+ );
}
}