use super::{MathLineKind, TexElement, TexParser};
mod tests {
use super::{TexElement, TexParser};
#[test]
fn parser_skips_unknown_command_and_continues() {
let content = r#"\documentclass{article}
\begin{document}
\undefined_command
Visible text
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::Text(text) if text.contains("Visible text"))
}));
}
#[test]
fn parser_unknown_command_with_argument_does_not_hang() {
let content = r#"\documentclass{article}
\begin{document}
\undefined{ignored}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(
elements.is_empty()
|| elements
.iter()
.all(|e| !matches!(e, TexElement::Command { .. }))
);
}
#[test]
fn parser_parses_lstlisting_environment() {
let content = r#"\documentclass{article}
\begin{document}
\begin{lstlisting}[language=Rust]
fn main() {
println!("Hello, World!");
}
\end{lstlisting}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::CodeBlock(code) if code.contains("fn main") && code.contains("println"))
}));
}
#[test]
fn parser_parses_sections() {
let content = r#"\documentclass{article}
\begin{document}
\section{Introduction}
Some intro text.
\subsection{Background}
Background info.
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::Section { level: 1, title } if title == "Introduction")
}));
assert!(elements.iter().any(|element| {
matches!(element, TexElement::Section { level: 2, title } if title == "Background")
}));
}
#[test]
fn parser_parses_deep_sections() {
let content = r#"\documentclass{article}
\begin{document}
\section{Intro}
\subsection{Method}
\subsubsection{Details}
\paragraph{Note}
\subparagraph{Fine Print}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(
elements.iter().any(|e| {
matches!(e, TexElement::Section { level: 1, title } if title == "Intro")
})
);
assert!(elements.iter().any(|e| {
matches!(e, TexElement::Section { level: 2, title } if title == "Method")
}));
assert!(elements.iter().any(|e| {
matches!(e, TexElement::Section { level: 3, title } if title == "Details")
}));
assert!(
elements.iter().any(|e| {
matches!(e, TexElement::Section { level: 4, title } if title == "Note")
})
);
assert!(elements.iter().any(|e| {
matches!(e, TexElement::Section { level: 5, title } if title == "Fine Print")
}));
}
#[test]
fn parser_parses_verbatim_environment() {
let content = r#"\documentclass{article}
\begin{document}
\begin{verbatim}
#include <stdio.h>
int main() {
printf("Hello\n");
return 0;
}
\end{verbatim}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::CodeBlock(code) if code.contains("#include") && code.contains("printf"))
}));
}
#[test]
fn verbatim_does_not_swallow_following_content() {
let content = r#"\documentclass{article}
\begin{document}
\begin{verbatim}
raw code
\end{verbatim}
\section{After}
Text after verbatim.
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
let code = elements.iter().find_map(|e| {
if let TexElement::CodeBlock(c) = e { Some(c) } else { None }
});
let code = code.expect("expected a CodeBlock");
assert_eq!(code, "raw code", "verbatim block should contain only its body");
assert!(
elements.iter().any(|e| matches!(e, TexElement::Section { title, .. } if title == "After")),
"section after verbatim must still be parsed"
);
}
#[test]
fn parser_parses_tableofcontents() {
let content = r#"\documentclass{article}
\begin{document}
\tableofcontents
\section{Intro}
Some text.
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(
elements
.iter()
.any(|e| { matches!(e, TexElement::TableOfContents) })
);
}
#[test]
fn parser_parses_inline_math_in_text() {
let content = r#"\documentclass{article}
\begin{document}
The equation $E = mc^2$ is famous.
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::Text(text) if text.contains("$E = mc^2$"))
}));
}
#[test]
fn parser_parses_display_math() {
let content = r#"\documentclass{article}
\begin{document}
\begin{equation}
a^2 + b^2 = c^2
\end{equation}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::MathDisplay(text) if text.contains("a^2 + b^2 = c^2"))
}));
}
#[test]
fn parser_parses_itemize() {
let content = r#"\documentclass{article}
\begin{document}
\begin{itemize}
\item First bullet
\item Second bullet
\end{itemize}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::ItemList { ordered: false, labels, items } if items.len() == 2 && labels.len() == 2)
}));
}
#[test]
fn parser_parses_enumerate() {
let content = r#"\documentclass{article}
\begin{document}
\begin{enumerate}
\item Step one
\item Step two
\end{enumerate}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::ItemList { ordered: true, labels, items } if items.len() == 2 && labels.len() == 2)
}));
}
#[test]
fn parser_extracts_metadata() {
let content = r#"\documentclass{article}
\title{Test Doc}
\author{Jane Doe}
\date{2024-01-01}
\begin{document}
\maketitle
Body text.
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::Command { name, args } if name == "title" && args[0] == "Test Doc")
}));
assert!(elements.iter().any(|element| {
matches!(element, TexElement::Command { name, args } if name == "author" && args[0] == "Jane Doe")
}));
}
#[test]
fn parser_parses_text_formatting() {
let content = r#"\documentclass{article}
\begin{document}
\textbf{bold} and \textit{italic} and \texttt{mono}.
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
let cmds: Vec<_> = elements
.iter()
.filter_map(|e| {
if let TexElement::Command { name, args } = e {
Some((name.clone(), args.clone()))
} else {
None
}
})
.collect();
assert!(
cmds.iter()
.any(|(n, a)| n == "textbf" && a == &["bold".to_string()])
);
assert!(
cmds.iter()
.any(|(n, a)| n == "textit" && a == &["italic".to_string()])
);
assert!(
cmds.iter()
.any(|(n, a)| n == "texttt" && a == &["mono".to_string()])
);
}
#[test]
fn parser_parses_includegraphics() {
let content = r#"\documentclass{article}
\begin{document}
\includegraphics{logo.png}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::Image { path, width, height } if path == "logo.png" && width.is_none() && height.is_none())
}));
}
#[test]
fn parser_parses_includegraphics_with_options() {
let content = r#"\documentclass{article}
\begin{document}
\includegraphics[width=5cm,height=3cm]{logo.png}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::Image { path, width, height }
if path == "logo.png"
&& width.as_deref() == Some("5cm")
&& height.as_deref() == Some("3cm"))
}));
}
#[test]
fn parser_parses_tabular() {
let content = r#"\documentclass{article}
\begin{document}
\begin{tabular}{lcr}
\hline
A & B & C \\
\hline
1 & 2 & 3 \\
\end{tabular}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
if let TexElement::Table(table) = element {
table.columns
== vec![
crate::table::Align::Left,
crate::table::Align::Center,
crate::table::Align::Right,
]
&& table.rows.len() == 4
&& table.rows[0].is_separator
&& table.rows[1].cells == vec!["A", "B", "C"]
&& table.rows[2].is_separator
&& table.rows[3].cells == vec!["1", "2", "3"]
} else {
false
}
}));
}
#[test]
fn parser_parses_table_environment() {
let content = r#"\documentclass{article}
\begin{document}
\begin{table}
\begin{tabular}{cc}
X & Y \\
\end{tabular}
\end{table}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
if let TexElement::Table(table) = element {
table.columns == vec![crate::table::Align::Center, crate::table::Align::Center]
&& table.rows.len() == 1
&& table.rows[0].cells == vec!["X", "Y"]
} else {
false
}
}));
}
#[test]
fn parser_parses_textcolor() {
let content = r#"\documentclass{article}
\begin{document}
\textcolor{red}{Important!}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::ColoredText { color, text } if color == "red" && text == "Important!")
}));
}
#[test]
fn parser_expands_newcommand_macro() {
let content = r#"\documentclass{article}
\newcommand{\hello}{Hello World}
\begin{document}
\hello
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::Text(t) if t.contains("Hello World"))
}));
}
#[test]
fn parser_expands_newcommand_with_args() {
let content = r#"\documentclass{article}
\newcommand{\greet}[1]{Hello, #1!}
\begin{document}
\greet{Alice}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::Text(t) if t.contains("Hello, Alice!"))
}));
}
#[test]
fn parser_expands_def_macro() {
let content = r#"\documentclass{article}
\def\twice#1{#1 #1}
\begin{document}
\twice{hi}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(
elements
.iter()
.any(|element| { matches!(element, TexElement::Text(t) if t.contains("hi hi")) })
);
}
#[test]
fn parser_parses_cite() {
let content = r#"\documentclass{article}
\begin{document}
See \cite{smith2024} for details.
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::Citation { keys, kind } if keys == &["smith2024"] && kind == "cite")
}));
}
#[test]
fn parser_parses_cite_multiple() {
let content = r#"\documentclass{article}
\begin{document}
See \cite{smith2024, jones2023}.
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::Citation { keys, kind } if keys == &["smith2024", "jones2023"] && kind == "cite")
}));
}
#[test]
fn parser_parses_thebibliography() {
let content = r#"\documentclass{article}
\begin{document}
\begin{thebibliography}{9}
\bibitem{smith2024} J. Smith, A Great Paper, Journal of Testing, 2024.
\bibitem{jones2023} A. Jones, Another Paper, 2023.
\end{thebibliography}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
if let TexElement::Bibliography { entries } = element {
entries.len() == 2
&& entries[0].key == "smith2024"
&& entries[0].text.contains("A Great Paper")
&& entries[1].key == "jones2023"
&& entries[1].text.contains("Another Paper")
} else {
false
}
}));
}
#[test]
fn parser_parses_label() {
let content = r#"\documentclass{article}
\begin{document}
\section{Intro}
\label{sec:intro}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(
elements.iter().any(|element| {
matches!(element, TexElement::Label { key } if key == "sec:intro")
})
);
}
#[test]
fn parser_parses_ref() {
let content = r#"\documentclass{article}
\begin{document}
See Section~\ref{sec:intro}.
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(
elements.iter().any(|element| {
matches!(element, TexElement::Ref { key } if key == "sec:intro")
})
);
}
#[test]
fn parser_parses_pageref() {
let content = r#"\documentclass{article}
\begin{document}
See page~\pageref{sec:intro}.
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::PageRef { key } if key == "sec:intro")
}));
}
#[test]
fn parser_plugin_handles_today() {
let content = r#"\documentclass{article}
\begin{document}
Today is \today.
\end{document}
"#;
let mut plugins = crate::plugins::PluginRegistry::new();
plugins.register(Box::new(crate::plugins::TodayPlugin));
let mut parser = TexParser::with_plugins(content.to_string(), plugins);
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::Command { name, args } if name == "today" && args.is_empty())
}));
}
#[test]
fn parser_plugin_handles_url() {
let content = r#"\documentclass{article}
\begin{document}
Visit \url{https://example.com}.
\end{document}
"#;
let mut plugins = crate::plugins::PluginRegistry::new();
plugins.register(Box::new(crate::plugins::UrlPlugin));
let mut parser = TexParser::with_plugins(content.to_string(), plugins);
let elements = parser.parse();
assert!(elements.iter().any(|element| {
matches!(element, TexElement::Command { name, args } if name == "url" && args == &["https://example.com"])
}));
}
#[test]
fn parser_parses_emph() {
let content = r#"\emph{important}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "emph" && args == &["important".to_string()])));
}
#[test]
fn parser_parses_newpage() {
let content = r#"\newpage"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "newpage" && args.is_empty())));
}
#[test]
fn parser_parses_clearpage() {
let content = r#"\clearpage"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "clearpage" && args.is_empty())));
}
#[test]
fn parser_parses_pagebreak() {
let content = r#"\pagebreak"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "pagebreak" && args.is_empty())));
}
#[test]
fn parser_parses_caption() {
let content = r#"\caption{A diagram showing the workflow.}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Caption { text } if text == "A diagram showing the workflow.")));
}
#[test]
fn parser_parses_vspace() {
let content = r#"\vspace{12pt}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "vspace" && args == &["12pt"])));
}
#[test]
fn parser_parses_underline() {
let content = r#"\underline{key}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "underline" && args == &["key"])));
}
#[test]
fn parser_parses_today() {
let content = r#"\today"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "today" && args.is_empty())));
}
#[test]
fn parser_parses_url() {
let content = r#"\url{https://example.com}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "url" && args == &["https://example.com"])));
}
#[test]
fn parser_parses_textsuperscript() {
let content = r#"\textsuperscript{st}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "textsuperscript" && args == &["st"])));
}
#[test]
fn parser_parses_textsubscript() {
let content = r#"\textsubscript{2}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "textsubscript" && args == &["2"])));
}
#[test]
fn parser_parses_raggedright() {
let content = r#"\raggedright some text"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "raggedright" && args.is_empty())));
}
#[test]
fn parser_parses_raggedleft() {
let content = r#"\raggedleft some text"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "raggedleft" && args.is_empty())));
}
#[test]
fn parser_parses_noindent() {
let content = r#"\noindent text"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "noindent" && args.is_empty())));
}
#[test]
fn parser_parses_fbox() {
let content = r#"\fbox{boxed text}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "fbox" && args == &["boxed text"])));
}
#[test]
fn parser_parses_rule() {
let content = r#"\rule{5cm}{0.4pt}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "rule" && args == &["5cm", "0.4pt"])));
}
#[test]
fn parser_parses_par() {
let content = r#"first \par second"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Paragraph)));
}
#[test]
fn parser_parses_font_size_commands() {
let sizes = [
"\\tiny",
"\\scriptsize",
"\\footnotesize",
"\\small",
"\\normalsize",
"\\large",
"\\Large",
"\\LARGE",
"\\huge",
"\\Huge",
];
for cmd in &sizes {
let content = format!("{}text", cmd);
let name = &cmd[1..]; let mut parser = TexParser::new(content);
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name: n, args } if n == name && args.is_empty())),
"failed to parse {}", cmd);
}
}
#[test]
fn parser_input_splices_file_content() {
use std::io::Write;
let tmp = tempfile::tempdir().unwrap();
let included = tmp.path().join("included.tex");
{
let mut f = std::fs::File::create(&included).unwrap();
f.write_all(b"\\textbf{included}").unwrap();
}
let content = r#"\input{included}"#;
let mut parser = TexParser::new(content.to_string()).with_base_dir(tmp.path());
let elements = parser.parse();
assert!(elements.iter().any(|e| {
matches!(e, TexElement::Command { name, args } if name == "textbf" && args == &["included".to_string()])
}));
}
#[test]
fn parser_skip_command_does_not_swallow_following_command() {
let content = r#"\setlength{\foo}{1cm}\textbf{bold} after"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(
elements.iter().any(|e| {
matches!(e, TexElement::Command { name, args }
if name == "textbf" && args == &["bold".to_string()])
}),
"textbf after a skip command must still parse, got {elements:?}"
);
}
#[test]
fn parser_input_content_parsed_by_correct_handler() {
use std::io::Write;
let tmp = tempfile::tempdir().unwrap();
let included = tmp.path().join("more.tex");
{
let mut f = std::fs::File::create(&included).unwrap();
f.write_all(b"\\emph{emphasis} \\label{key:x}").unwrap();
}
let content = r#"\input{more}"#;
let mut parser = TexParser::new(content.to_string()).with_base_dir(tmp.path());
let elements = parser.parse();
assert!(
elements.iter().any(|e| {
matches!(e, TexElement::Command { name, args }
if name == "emph" && args == &["emphasis".to_string()])
}),
"emph from spliced file must parse, got {elements:?}"
);
assert!(
elements.iter().any(|e| matches!(e, TexElement::Label { key } if key == "key:x")),
"label from spliced file must parse, got {elements:?}"
);
}
#[test]
fn parser_input_adds_tex_extension() {
use std::io::Write;
let tmp = tempfile::tempdir().unwrap();
let included = tmp.path().join("chapter1.tex");
{
let mut f = std::fs::File::create(&included).unwrap();
f.write_all(b"Chapter text").unwrap();
}
let content = r#"\input{chapter1}"#;
let mut parser = TexParser::new(content.to_string()).with_base_dir(tmp.path());
let elements = parser.parse();
assert!(elements.iter().any(|e| {
if let TexElement::Text(t) = e {
t.contains("Chapter text")
} else {
false
}
}));
}
#[test]
fn parser_input_missing_file_is_noop() {
let content = r#"\input{nonexistent}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(
!elements
.iter()
.any(|e| matches!(e, TexElement::Command { name, .. } if name == "newpage"))
);
}
#[test]
fn parser_input_without_braces() {
use std::io::Write;
let tmp = tempfile::tempdir().unwrap();
let included = tmp.path().join("chapter1.tex");
{
let mut f = std::fs::File::create(&included).unwrap();
f.write_all(b"Chapter text").unwrap();
}
let content = r#"\input chapter1
More text"#;
let mut parser = TexParser::new(content.to_string()).with_base_dir(tmp.path());
let elements = parser.parse();
assert!(elements.iter().any(|e| {
if let TexElement::Text(t) = e {
t.contains("Chapter text")
} else {
false
}
}));
assert!(elements.iter().any(|e| {
if let TexElement::Text(t) = e {
t.contains("More text")
} else {
false
}
}));
}
#[test]
fn parser_include_splices_with_clearpage() {
use std::io::Write;
let tmp = tempfile::tempdir().unwrap();
let included = tmp.path().join("chapter2.tex");
{
let mut f = std::fs::File::create(&included).unwrap();
f.write_all(b"Included chapter").unwrap();
}
let content = r#"\include{chapter2}"#;
let mut parser = TexParser::new(content.to_string()).with_base_dir(tmp.path());
let elements = parser.parse();
assert!(elements.iter().any(|e| {
if let TexElement::Text(t) = e {
t.contains("Included chapter")
} else {
false
}
}));
assert!(elements
.iter()
.any(|e| matches!(e, TexElement::Command { name, .. } if name == "clearpage")));
}
#[test]
fn parser_parses_centering_command() {
let content = r#"\centering centered text"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "centering" && args.is_empty())));
}
#[test]
fn parser_parses_center_environment() {
let content = r#"\begin{center}centered text\end{center}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| {
if let TexElement::Center(inner) = e {
inner
.iter()
.any(|i| matches!(i, TexElement::Text(t) if t.contains("centered")))
} else {
false
}
}));
}
#[test]
fn parser_parses_footnote() {
let content = r#"Hello\footnote{This is a note.}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(
elements
.iter()
.any(|e| matches!(e, TexElement::Footnote { text } if text == "This is a note."))
);
}
#[test]
fn parser_parses_part() {
let content = r#"\part{The Beginning}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(
|e| matches!(e, TexElement::Section { level: 0, title } if title == "The Beginning")
));
}
#[test]
fn parser_parses_chapter() {
let content = r#"\chapter{Intro}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(
elements
.iter()
.any(|e| matches!(e, TexElement::Section { level: 6, title } if title == "Intro"))
);
}
#[test]
fn parser_parses_quote() {
let content = r#"\begin{quote}A famous quote.\end{quote}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| {
matches!(e, TexElement::Quote(inner) if inner.iter().any(|i| matches!(i, TexElement::Text(t) if t.contains("famous"))))
}));
}
#[test]
fn parser_parses_quotation() {
let content = r#"\begin{quotation}A longer quotation.\end{quotation}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| {
matches!(e, TexElement::Quote(inner) if inner.iter().any(|i| matches!(i, TexElement::Text(t) if t.contains("longer"))))
}));
}
#[test]
fn parser_parses_abstract() {
let content = r#"\begin{abstract}This is the abstract.\end{abstract}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| {
matches!(e, TexElement::Abstract(inner) if inner.iter().any(|i| matches!(i, TexElement::Text(t) if t.contains("abstract"))))
}));
}
#[test]
fn parser_parses_item_with_label() {
let content = r#"\begin{itemize}\item[Key] Value\end{itemize}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| {
matches!(e, TexElement::ItemList { labels, items, .. } if labels.len() == 1 && labels[0] == Some("Key".to_string()) && items.len() == 1)
}));
}
#[test]
fn parser_parses_listoffigures() {
let content = r#"\listoffigures"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(
elements
.iter()
.any(|e| matches!(e, TexElement::ListOfFigures))
);
}
#[test]
fn parser_parses_listoftables() {
let content = r#"\listoftables"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(
elements
.iter()
.any(|e| matches!(e, TexElement::ListOfTables))
);
}
#[test]
fn parser_parses_text_command() {
let content = r#"\text{plain text}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "text" && args == &["plain text"])));
}
#[test]
fn parser_parses_ensuremath() {
let content = r#"\ensuremath{x^2}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "ensuremath" && args == &["x^2"])));
}
#[test]
fn parser_parses_overline() {
let content = r#"\overline{AB}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "overline" && args == &["AB"])));
}
#[test]
fn parser_parses_sout() {
let content = r#"\sout{deleted}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "sout" && args == &["deleted"])));
}
#[test]
fn parser_parses_textsc() {
let content = r#"\textsc{Small Caps}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "textsc" && args == &["Small Caps"])));
}
#[test]
fn parser_parses_textrm() {
let content = r#"\textrm{roman}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "textrm" && args == &["roman"])));
}
#[test]
fn parser_parses_textsf() {
let content = r#"\textsf{sans}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "textsf" && args == &["sans"])));
}
#[test]
fn parser_parses_textsl() {
let content = r#"\textsl{slanted}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "textsl" && args == &["slanted"])));
}
#[test]
fn parser_parses_textup() {
let content = r#"\textup{upright}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "textup" && args == &["upright"])));
}
#[test]
fn parser_parses_textmd() {
let content = r#"\textmd{medium}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "textmd" && args == &["medium"])));
}
#[test]
fn parser_parses_phantom() {
let content = r#"\phantom{hidden}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "phantom" && args == &["hidden"])));
}
#[test]
fn parser_parses_vphantom() {
let content = r#"\vphantom{hidden}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "vphantom" && args == &["hidden"])));
}
#[test]
fn parser_parses_hphantom() {
let content = r#"\hphantom{hidden}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "hphantom" && args == &["hidden"])));
}
#[test]
fn parser_parses_raisebox() {
let content = r#"\raisebox{2pt}{raised text}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "raisebox" && args == &["2pt", "raised text"])));
}
#[test]
fn parser_parses_bibliography() {
let content = r#"\bibliography{refs}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "bibliography" && args == &["refs"])));
}
#[test]
fn parser_parses_bibliographystyle() {
let content = r#"\bibliographystyle{plain}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "bibliographystyle" && args == &["plain"])));
}
#[test]
fn parser_parses_appendix() {
let content = r#"\appendix"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "appendix" && args.is_empty())));
}
#[test]
fn parser_parses_index() {
let content = r#"\index{term}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "index" && args == &["term"])));
}
#[test]
fn parser_parses_glossary() {
let content = r#"\glossary{term}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "glossary" && args == &["term"])));
}
#[test]
fn parser_parses_rotatebox() {
let content = r#"\rotatebox{90}{text}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "rotatebox" && args == &["90", "text"])));
}
#[test]
fn parser_parses_scalebox() {
let content = r#"\scalebox{2}{text}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "scalebox" && args == &["2", "text"])));
}
#[test]
fn parser_parses_font_declarations() {
let mut parser = TexParser::new(r#"\em \bf \it \rm \sf \tt \sc \sl"#.to_string());
let elements = parser.parse();
let names: Vec<&str> = elements
.iter()
.filter_map(|e| {
if let TexElement::Command { name, args } = e {
if args.is_empty() {
Some(name.as_str())
} else {
None
}
} else {
None
}
})
.collect();
assert!(names.contains(&"em"));
assert!(names.contains(&"bf"));
assert!(names.contains(&"it"));
assert!(names.contains(&"rm"));
assert!(names.contains(&"sf"));
assert!(names.contains(&"tt"));
assert!(names.contains(&"sc"));
assert!(names.contains(&"sl"));
}
#[test]
fn parser_parses_text_special_chars() {
let cases = [
("\\textasciicircum", "^"),
("\\textasciitilde", "~"),
("\\textbackslash", "\\"),
("\\textbar", "|"),
("\\textbraceleft", "{"),
("\\textbraceright", "}"),
("\\textdollar", "$"),
("\\textgreater", ">"),
("\\textless", "<"),
];
for (cmd, expected) in &cases {
let mut parser = TexParser::new(cmd.to_string());
let elements = parser.parse();
assert!(
elements
.iter()
.any(|e| matches!(e, TexElement::Text(t) if t == *expected)),
"Command {} should produce text {}",
cmd,
expected
);
}
}
#[test]
fn parser_parses_colorbox() {
let content = r#"\colorbox{red}{hello}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "colorbox" && args == &["red", "hello"])));
}
#[test]
fn parser_parses_fcolorbox() {
let content = r#"\fcolorbox{black}{yellow}{hello}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "fcolorbox" && args == &["black", "yellow", "hello"])));
}
#[test]
fn parser_parses_spacing_commands() {
let cmds = [
"\\hfill",
"\\vfill",
"\\hrulefill",
"\\dotfill",
"\\fill",
"\\medskip",
"\\bigskip",
"\\smallskip",
"\\strut",
"\\mathstrut",
"\\qquad",
"\\quad",
"\\;",
"\\,",
"\\!",
"\\:",
"\\ ",
];
for cmd in &cmds {
let mut parser = TexParser::new(cmd.to_string());
let elements = parser.parse();
let expected_name = match *cmd {
"\\hfill" => "hfill",
"\\vfill" => "vfill",
"\\hrulefill" => "hrulefill",
"\\dotfill" => "dotfill",
"\\fill" => "fill",
"\\medskip" => "medskip",
"\\bigskip" => "bigskip",
"\\smallskip" => "smallskip",
"\\strut" => "strut",
"\\mathstrut" => "mathstrut",
"\\qquad" => "qquad",
"\\quad" => "quad",
"\\;" => "semicolon",
"\\," => "comma",
"\\!" => "bang",
"\\:" => "colon",
"\\ " => "control_space",
_ => "",
};
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == expected_name && args.is_empty())),
"Command {} should produce Command {{ name: {}, args: [] }}", cmd, expected_name);
}
}
#[test]
fn parser_parses_description_environment() {
let content = r#"\documentclass{article}
\begin{document}
\begin{description}
\item[Apple] A red fruit.
\item[Bear] A large mammal.
\end{description}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
let desc = elements.iter().find_map(|e| match e {
TexElement::DescriptionList { items } => Some(items),
_ => None,
});
let items = desc.expect("should produce a DescriptionList");
assert_eq!(items.len(), 2);
assert_eq!(items[0].term, "Apple");
assert_eq!(items[1].term, "Bear");
assert!(
items[0]
.body
.iter()
.any(|e| matches!(e, TexElement::Text(t) if t.contains("red fruit")))
);
}
#[test]
fn parser_parses_description_with_unlabeled_items() {
let content = r#"\begin{document}
\begin{description}
\item plain body text
\item[Labeled] second body
\end{description}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
let items = elements
.iter()
.find_map(|e| match e {
TexElement::DescriptionList { items } => Some(items),
_ => None,
})
.expect("DescriptionList present");
assert_eq!(items.len(), 2);
assert_eq!(items[0].term, "");
assert_eq!(items[1].term, "Labeled");
}
#[test]
fn parser_parses_align_environment() {
let content = r#"\begin{document}
\begin{align}
a &= b + c \\
d &= e + f
\end{align}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
let ml = elements.iter().find_map(|e| match e {
TexElement::MathLines { lines, kind } => Some((lines, kind)),
_ => None,
});
let (lines, kind) = ml.expect("should produce a MathLines element");
assert_eq!(lines.len(), 2);
assert!(matches!(kind, super::MathLineKind::Align));
assert!(
lines[0].contains('&'),
"& should be preserved as an alignment marker for the PDF backend"
);
}
#[test]
fn parser_parses_align_starred_environment() {
let content = r#"\begin{document}
\begin{align*}
x &= 1 \\
y &= 2
\end{align*}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(
elements
.iter()
.any(|e| matches!(e, TexElement::MathLines { lines, .. } if lines.len() == 2))
);
}
#[test]
fn parser_parses_gather_environment() {
let content = r#"\begin{document}
\begin{gather}
x = 1 \\
y = 2 \\
z = 3
\end{gather}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
let lines = elements
.iter()
.find_map(|e| match e {
TexElement::MathLines { lines, .. } => Some(lines),
_ => None,
})
.expect("gather should produce MathLines");
assert_eq!(lines.len(), 3);
}
#[test]
fn parser_parses_multline_environment() {
let content = r#"\begin{document}
\begin{multline}
a + b + c + d + e + f \\
+ g + h
\end{multline}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
let ml = elements.iter().find_map(|e| match e {
TexElement::MathLines { lines, kind } => Some((lines, kind)),
_ => None,
});
let (lines, kind) = ml.expect("multline should produce MathLines");
assert_eq!(lines.len(), 2);
assert!(matches!(kind, super::MathLineKind::Multline));
}
#[test]
fn parser_parses_cases_environment() {
let content = r#"\begin{document}
\begin{cases}
x & \text{if } x \geq 0 \\
-x & \text{if } x < 0
\end{cases}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
let ml = elements.iter().find_map(|e| match e {
TexElement::MathLines { lines, kind } => Some((lines, kind)),
_ => None,
});
let (lines, kind) = ml.expect("cases should produce MathLines");
assert_eq!(lines.len(), 2);
assert!(matches!(kind, super::MathLineKind::Cases));
assert!(
lines[0].contains("if"),
"cases should include 'if' between value and condition"
);
}
#[test]
fn parser_parses_href_command() {
let content = r#"\documentclass{article}
\begin{document}
Visit \href{https://example.com}{Example Site} for more.
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
let href = elements.iter().find_map(|e| match e {
TexElement::Command { name, args } if name == "href" => Some(args),
_ => None,
});
let args = href.expect("\\href should produce a Command");
assert_eq!(args[0], "https://example.com");
assert_eq!(args[1], "Example Site");
}
#[test]
fn parser_parses_bracket_math_delimiters() {
let inline = r#"\documentclass{article}
\begin{document}
Inline \(E = mc^2\) math.
\end{document}"#;
let mut p = TexParser::new(inline.to_string());
let els = p.parse();
assert!(
els.iter()
.any(|e| matches!(e, TexElement::MathInline(s) if s.contains("E = mc^2")))
);
let display = r#"\documentclass{article}
\begin{document}
Display \[ \int_0^\infty e^{-x} dx = 1 \] math.
\end{document}"#;
let mut p = TexParser::new(display.to_string());
let els = p.parse();
assert!(
els.iter()
.any(|e| matches!(e, TexElement::MathDisplay(s) if s.contains("infty")))
);
}
#[test]
fn parser_parses_theorem_environment() {
let content = r#"\documentclass{article}
\begin{document}
\begin{theorem}[Pythagoras]
For a right triangle with legs $a, b$ and hypotenuse $c$, $a^2 + b^2 = c^2$.
\end{theorem}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
let thm = elements.iter().find_map(|e| match e {
TexElement::Theorem { kind, title, body } => Some((kind, title, body)),
_ => None,
});
let (kind, title, body) = thm.expect("should produce a Theorem element");
assert_eq!(kind, "theorem");
assert_eq!(title.as_deref(), Some("Pythagoras"));
assert!(
body.iter()
.any(|e| matches!(e, TexElement::Text(t) if t.contains("right triangle")))
);
}
#[test]
fn parser_parses_proof_environment_without_title() {
let content = r#"\begin{document}
\begin{proof}
By induction. QED.
\end{proof}
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
let thm = elements.iter().find_map(|e| match e {
TexElement::Theorem { kind, title, .. } => Some((kind, title)),
_ => None,
});
let (kind, title) = thm.expect("proof should produce a Theorem element");
assert_eq!(kind, "proof");
assert!(title.is_none());
}
#[test]
fn parser_parses_starred_sections() {
let content = r#"\documentclass{article}
\begin{document}
\section*{Acknowledgement}
Thanks.
\subsection*{Preface}
Lead-in text.
\subsubsection*{Notes}
Body.
\end{document}
"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
let titles: Vec<(&usize, &String)> = elements
.iter()
.filter_map(|e| match e {
TexElement::Section { level, title } => Some((level, title)),
_ => None,
})
.collect();
assert_eq!(
titles.len(),
3,
"expected 3 starred sections, got {titles:?}"
);
assert_eq!(titles[0], (&1, &"Acknowledgement".to_string()));
assert_eq!(titles[1], (&2, &"Preface".to_string()));
assert_eq!(titles[2], (&3, &"Notes".to_string()));
}
#[test]
fn parser_splits_cases_inside_display_math() {
let content = r#"\documentclass{article}
\begin{document}
\[
f(x) = \begin{cases}
x^2 & \text{if } x \geq 0 \\
-x & \text{if } x < 0
\end{cases}
\]
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
let mut found_prefix = false;
for elem in &elements {
match elem {
TexElement::MathLines { lines, .. } => {
if lines.first().map(|s| s.contains("f(x) =")).unwrap_or(false) {
found_prefix = true;
}
}
TexElement::MathDisplay(text) => {
if text.contains("f(x) =") {
found_prefix = true;
}
}
_ => {}
}
}
assert!(found_prefix, "expected 'f(x) =' prefix to be preserved");
}
#[test]
fn parser_parses_line_break() {
let content = r#"\documentclass{article}
\begin{document}
First line \\ Second line
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::LineBreak)),
"Expected a LineBreak element");
}
#[test]
fn parser_parses_line_break_with_opt_arg() {
let content = r#"\documentclass{article}
\begin{document}
A \\[2em] B
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::LineBreak)),
"Expected LineBreak with optional [length] argument");
}
#[test]
fn parser_parses_extended_special_chars() {
let cases = [
("\\copyright", "©"),
("\\pounds", "£"),
("\\S", "§"),
("\\P", "¶"),
("\\dag", "†"),
("\\ddag", "‡"),
("\\ldots", "…"),
("\\dots", "…"),
("\\LaTeX", "LaTeX"),
("\\TeX", "TeX"),
("\\AA", "Å"),
("\\aa", "å"),
("\\ss", "ß"),
];
for (cmd, expected) in &cases {
let mut parser = TexParser::new(cmd.to_string());
let elements = parser.parse();
assert!(
elements.iter().any(|e| matches!(e, TexElement::Text(t) if t == *expected)),
"Command {} should produce text {}",
cmd,
expected
);
}
}
#[test]
fn parser_special_chars_word_boundary() {
let mut parser = TexParser::new("\\it".to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "it")),
"\\it should be a Command, not consumed by \\i special char");
}
#[test]
fn parser_parses_flushleft() {
let content = r#"\documentclass{article}
\begin{document}
\begin{flushleft}
Left aligned text
\end{flushleft}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::FlushLeft(_))),
"Expected FlushLeft element");
}
#[test]
fn parser_parses_flushright() {
let content = r#"\documentclass{article}
\begin{document}
\begin{flushright}
Right aligned text
\end{flushright}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::FlushRight(_))),
"Expected FlushRight element");
}
#[test]
fn parser_parses_figure() {
let content = r#"\documentclass{article}
\begin{document}
\begin{figure}
\centering
\caption{Test figure}
\end{figure}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Center(_))),
"Expected figure to produce Center element");
}
#[test]
fn parser_parses_displaymath_env() {
let content = r#"\documentclass{article}
\begin{document}
\begin{displaymath}
E = mc^2
\end{displaymath}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::MathDisplay(_))),
"Expected displaymath environment to produce MathDisplay");
}
#[test]
fn parser_parses_math_env() {
let content = r#"\documentclass{article}
\begin{document}
\begin{math} x + y \end{math}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::MathInline(_))),
"Expected math environment to produce MathInline");
}
#[test]
fn parser_skips_setlength() {
let content = r#"\documentclass{article}
\begin{document}
\setlength{\parindent}{0pt}
Hello
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "setlength")),
"setlength should be silently consumed");
}
#[test]
fn parser_skips_setcounter() {
let content = r#"\documentclass{article}
\begin{document}
\setcounter{page}{3}
Hello
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "setcounter")),
"setcounter should be silently consumed");
}
#[test]
fn parser_parses_hspace() {
let content = r#"\documentclass{article}
\begin{document}
A\hspace{1em}B
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "hspace" && args == &["1em"])),
"Expected hspace command");
}
#[test]
fn parser_parses_multicolumn() {
let content = r#"\documentclass{article}
\begin{document}
\multicolumn{2}{c}{Header}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "multicolumn" && args.len() == 3)),
"Expected multicolumn command with 3 args");
}
#[test]
fn parser_parses_enquote() {
let content = r#"\documentclass{article}
\begin{document}
\enquote{Hello world}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "enquote" && args == &["Hello world"])),
"Expected enquote command");
}
#[test]
fn parser_parses_mbox() {
let content = r#"\documentclass{article}
\begin{document}
\mbox{Hello}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "mbox" && args == &["Hello"])),
"Expected mbox command");
}
#[test]
fn parser_parses_parbox() {
let content = r#"\documentclass{article}
\begin{document}
\parbox[c]{3cm}{Centered text}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "parbox" && args == &["Centered text"])),
"Expected parbox command with text content");
}
#[test]
fn parser_parses_minipage() {
let content = r#"\documentclass{article}
\begin{document}
\begin{minipage}[c]{0.5\textwidth}
Hello minipage
\end{minipage}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Center(_))),
"Expected minipage to produce Center element");
}
#[test]
fn parser_parses_newpage_command() {
let content = r#"\documentclass{article}
\begin{document}
First page\newpage
Second page
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "newpage")),
"Expected newpage command");
}
#[test]
fn parser_parses_pagebreak_with_optional_arg() {
let content = r#"\documentclass{article}
\begin{document}
Text\pagebreak[2]
More text
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "pagebreak")),
"Expected pagebreak command");
assert!(elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("More text"))),
"Text after pagebreak should still parse");
}
#[test]
fn parser_parses_noindent_and_par() {
let content = r#"\documentclass{article}
\begin{document}
\noindent First paragraph\par
Second paragraph
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "noindent")),
"Expected noindent command");
assert!(elements.iter().any(|e| matches!(e, TexElement::Paragraph)),
"Expected par to produce Paragraph element");
}
#[test]
fn parser_consumes_marginpar() {
let content = r#"\documentclass{article}
\begin{document}
Text\marginpar{note}
More text
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("note"))),
"Marginpar content should be consumed, not rendered");
assert!(elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("More text"))),
"Text after marginpar should still parse");
}
#[test]
fn parser_parses_nocite() {
let content = r#"\documentclass{article}
\begin{document}
\nocite{key1,key2}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Citation { keys, kind } if *keys == vec!["key1".to_string(), "key2".to_string()] && kind == "nocite")),
"Expected nocite to produce Citation element");
}
#[test]
fn parser_parses_eqref() {
let content = r#"\documentclass{article}
\begin{document}
See \eqref{fig:1} for details
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Ref { key } if key == "fig:1")),
"Expected eqref to produce Ref element");
}
#[test]
fn parser_parses_autoref() {
let content = r#"\documentclass{article}
\begin{document}
See \autoref{sec:intro} for details
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Ref { key } if key == "sec:intro")),
"Expected autoref to produce Ref element");
}
#[test]
fn parser_parses_nameref() {
let content = r#"\documentclass{article}
\begin{document}
See \nameref{sec:intro} for details
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Ref { key } if key == "sec:intro")),
"Expected nameref to produce Ref element");
}
#[test]
fn parser_skips_pagestyle() {
let content = r#"\documentclass{article}
\pagestyle{plain}
\begin{document}
Hello
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("plain"))),
"pagestyle should be consumed");
}
#[test]
fn parser_skips_pagenumbering() {
let content = r#"\documentclass{article}
\begin{document}
\pagenumbering{arabic}
Hello
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("arabic"))),
"pagenumbering should be consumed");
assert!(elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("Hello"))),
"Text after pagenumbering should still parse");
}
#[test]
fn parser_skips_definecolor() {
let content = r#"\documentclass{article}
\definecolor{myred}{rgb}{0.8,0.0,0.0}
\begin{document}
Hello
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("myred"))),
"definecolor should be consumed");
}
#[test]
fn parser_parses_textcircled() {
let content = r#"\documentclass{article}
\begin{document}
\textcircled{a}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "textcircled")),
"Expected textcircled command");
}
#[test]
fn parser_parses_hl() {
let content = r#"\documentclass{article}
\begin{document}
\hl{highlighted}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "hl")),
"Expected hl command");
}
#[test]
fn parser_parses_uline() {
let content = r#"\documentclass{article}
\begin{document}
\uline{underlined}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "uline")),
"Expected uline command");
}
#[test]
fn parser_parses_color_declaration() {
let content = r#"\documentclass{article}
\begin{document}
\color{red} Red text
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "color")),
"Expected color command");
}
#[test]
fn parser_skips_let() {
let content = r#"\documentclass{article}
\let\oldsection\section
\begin{document}
Hello
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("oldsection"))),
"\\let should be consumed");
}
#[test]
fn parser_skips_endsloppypar() {
let content = r#"\documentclass{article}
\begin{document}
\sloppypar
Loose text.
\endsloppypar
After.
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("endsloppypar") || t.contains("sloppypar"))),
"\\sloppypar and \\endsloppypar should be consumed, not leaked into text");
}
#[test]
fn parser_skips_parindent() {
let content = r#"\documentclass{article}
\setlength{\parindent}{0pt}
\begin{document}
Hello
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("parindent"))),
"setlength with parindent should be consumed");
}
#[test]
fn parser_converts_text_ligatures() {
let content = "Pages 10--20 show ``quotes'' and an em---dash.";
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
let joined: String = elements
.iter()
.filter_map(|e| match e {
TexElement::Text(t) => Some(t.as_str()),
_ => None,
})
.collect();
assert!(joined.contains('\u{2013}'), "en-dash: {joined:?}");
assert!(joined.contains('\u{2014}'), "em-dash: {joined:?}");
assert!(joined.contains('\u{201C}'), "left double quote: {joined:?}");
assert!(joined.contains('\u{201D}'), "right double quote: {joined:?}");
assert!(!joined.contains("--"), "raw -- should be gone: {joined:?}");
}
#[test]
fn parser_preserves_ligatures_in_math() {
let content = "See $a -- b$ here.";
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
let joined: String = elements
.iter()
.filter_map(|e| match e {
TexElement::Text(t) => Some(t.as_str()),
_ => None,
})
.collect();
assert!(joined.contains("$a -- b$"), "math span preserved verbatim: {joined:?}");
assert!(!joined.contains('\u{2013}'), "no en-dash in math: {joined:?}");
}
#[test]
fn parser_skips_floatsep() {
let content = r#"\documentclass{article}
\floatsep{12pt}
\begin{document}
Hello
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("floatsep"))),
"floatsep should be consumed");
assert!(elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("Hello"))),
"Text after floatsep should still parse");
}
#[test]
fn parser_parses_normalcolor() {
let content = r#"\documentclass{article}
\begin{document}
\color{red} Red \normalcolor normal
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "normalcolor")),
"Expected normalcolor command");
}
#[test]
fn parser_parses_tag() {
let content = r#"\documentclass{article}
\begin{document}
\tag{1.1} x = y
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "tag")),
"Expected tag command");
}
#[test]
fn parser_parses_tag_star() {
let content = r#"\documentclass{article}
\begin{document}
\tag*{1.1} x = y
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "tag*")),
"Expected tag* command");
}
#[test]
fn parser_parses_intertext() {
let content = r#"\documentclass{article}
\begin{document}
\intertext{Some text}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "intertext")),
"Expected intertext command");
}
#[test]
fn parser_parses_reflectbox() {
let content = r#"\documentclass{article}
\begin{document}
\reflectbox{mirrored}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "reflectbox")),
"Expected reflectbox command");
}
#[test]
fn parser_parses_resizebox() {
let content = r#"\documentclass{article}
\begin{document}
\resizebox{5cm}{3cm}{content}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "resizebox")),
"Expected resizebox command");
}
#[test]
fn parser_skips_nonumber() {
let content = r#"\documentclass{article}
\begin{document}
Hello \nonumber world
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("nonumber"))),
"\\nonumber should be consumed");
}
#[test]
fn parser_skips_theoremstyle() {
let content = r#"\documentclass{article}
\theoremstyle{plain}
\begin{document}
Hello
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("plain"))),
"\\theoremstyle should be consumed");
}
#[test]
fn parser_skips_sbox() {
let content = r#"\documentclass{article}
\sbox{\mybox}{content}
\begin{document}
Hello
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("mybox"))),
"\\sbox should be consumed");
}
#[test]
fn parser_parses_textcite() {
let content = r#"\documentclass{article}
\begin{document}
\textcite{smith2024} showed that.
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Citation { keys, kind } if keys == &["smith2024"] && kind == "textcite")),
"Expected textcite Citation");
}
#[test]
fn parser_parses_parencite() {
let content = r#"\documentclass{article}
\begin{document}
\parencite{jones2023} found that.
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Citation { keys, kind } if keys == &["jones2023"] && kind == "parencite")),
"Expected parencite Citation");
}
#[test]
fn parser_parses_footcite() {
let content = r#"\documentclass{article}
\begin{document}
\footcite{doe2021} noted that.
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Citation { keys, kind } if keys == &["doe2021"] && kind == "footcite")),
"Expected footcite Citation");
}
#[test]
fn parser_parses_citeauthor() {
let content = r#"\documentclass{article}
\begin{document}
\citeauthor{smith2024} argued that.
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Citation { keys, kind } if keys == &["smith2024"] && kind == "citeauthor")),
"Expected citeauthor Citation");
}
#[test]
fn parser_parses_citeyear() {
let content = r#"\documentclass{article}
\begin{document}
In \citeyear{smith2024} it was shown.
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Citation { keys, kind } if keys == &["smith2024"] && kind == "citeyear")),
"Expected citeyear Citation");
}
#[test]
fn parser_parses_citetitle() {
let content = r#"\documentclass{article}
\begin{document}
\citetitle{smith2024} is a great paper.
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Citation { keys, kind } if keys == &["smith2024"] && kind == "citetitle")),
"Expected citetitle Citation");
}
#[test]
fn parser_parses_fullcite() {
let content = r#"\documentclass{article}
\begin{document}
\fullcite{smith2024}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Citation { keys, kind } if keys == &["smith2024"] && kind == "fullcite")),
"Expected fullcite Citation");
}
#[test]
fn parser_parses_printbibliography() {
let content = r#"\documentclass{article}
\begin{document}
Text.
\printbibliography
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "printbibliography" && args.is_empty())),
"Expected printbibliography command");
}
#[test]
fn parser_parses_printbibliography_with_opts() {
let content = r#"\documentclass{article}
\begin{document}
Text.
\printbibliography[title={References}]
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "printbibliography" && args.is_empty())),
"Expected printbibliography command with optional args consumed");
}
#[test]
fn parser_parses_addbibresource() {
let content = r#"\addbibresource{refs.bib}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "addbibresource" && args == &["refs.bib"])),
"Expected addbibresource command");
}
#[test]
fn parser_parses_tabular_star() {
let content = r#"\documentclass{article}
\begin{document}
\begin{tabular*}{\textwidth}{lc}
A & B \\
C & D \\
\end{tabular*}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Table(_))),
"Expected Table from tabular*");
}
#[test]
fn parser_parses_tabularx() {
let content = r#"\documentclass{article}
\usepackage{tabularx}
\begin{document}
\begin{tabularx}{\textwidth}{lX}
A & B \\
C & D \\
\end{tabularx}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Table(_))),
"Expected Table from tabularx");
}
#[test]
fn parser_parses_array_env() {
let content = r#"\documentclass{article}
\begin{document}
\[
\left( \begin{array}{cc} a & b \\ c & d \end{array} \right)
\]
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Table(_) | TexElement::MathDisplay(_))),
"Expected Table or MathDisplay from array env");
}
#[test]
fn parser_skips_comment_env() {
let content = r#"\documentclass{article}
\begin{document}
Before.
\begin{comment}
This should be ignored.
\end{comment}
After.
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("should be ignored"))),
"comment environment content should be discarded");
}
#[test]
fn parser_parses_subfigure() {
let content = r#"\documentclass{article}
\usepackage{subfigure}
\begin{document}
\begin{subfigure}{0.5\textwidth}
\includegraphics{img1.png}
\caption{First}
\end{subfigure}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "subfigure")),
"Expected subfigure command");
}
#[test]
fn parser_parses_caption_star() {
let content = r#"\documentclass{article}
\begin{document}
\caption*{Unnumbered caption}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "caption*" && args == &["Unnumbered caption"])),
"Expected caption* command");
}
#[test]
fn parser_parses_multirow() {
let content = r#"\documentclass{article}
\begin{document}
\begin{tabular}{|c|c|}
\multirow{2}{*}{A} & B \\
& C \\
\end{tabular}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Table(_))),
"Expected Table with multirow");
}
#[test]
fn parser_parses_rowcolor() {
let content = r#"\documentclass{article}
\begin{document}
\begin{tabular}{|c|c|}
\rowcolor{red} A & B \\
C & D \\
\end{tabular}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Table(_))),
"Expected Table with rowcolor");
}
#[test]
fn parser_skips_floatbarrier() {
let content = r#"\documentclass{article}
\begin{document}
Before \floatbarrier after.
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("floatbarrier"))),
"\\floatbarrier should be consumed");
}
#[test]
fn parser_parses_textellipsis() {
let content = r#"\documentclass{article}
\begin{document}
Hello\textellipsis world
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains('…'))),
"\\textellipsis should produce ellipsis character");
}
#[test]
fn parser_skips_stretch() {
let content = r#"\documentclass{article}
\begin{document}
A \stretch{1} B
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("stretch"))),
"\\stretch should be consumed");
}
#[test]
fn parser_parses_multicols() {
let content = r#"\documentclass{article}
\usepackage{multicol}
\begin{document}
\begin{multicols}{2}
Column text here.
\end{multicols}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "multicols")),
"Expected multicols command");
}
#[test]
fn parser_parses_wrapfigure() {
let content = r#"\documentclass{article}
\usepackage{wrapfig}
\begin{document}
\begin{wrapfigure}{r}{0.5\textwidth}
\includegraphics{img.png}
\caption{Test}
\end{wrapfigure}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Center(_))),
"Expected Center from wrapfigure");
}
#[test]
fn parser_parses_wraptable() {
let content = r#"\documentclass{article}
\usepackage{wrapfig}
\begin{document}
\begin{wraptable}{r}{0.5\textwidth}
\begin{tabular}{|c|c|}
A & B \\
\end{tabular}
\end{wraptable}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Table(_))),
"Expected Table from wraptable");
}
#[test]
fn parser_parses_tabbing() {
let content = r#"\documentclass{article}
\begin{document}
\begin{tabbing}
foo \= bar \= baz \\
\> 1 \> 2
\end{tabbing}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Center(_))),
"Expected Center from tabbing");
}
#[test]
fn parser_parses_algorithm() {
let content = r#"\documentclass{article}
\usepackage{algorithm}
\begin{document}
\begin{algorithm}
\caption{My Algorithm}
\end{algorithm}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Center(_))),
"Expected Center from algorithm");
}
#[test]
fn parser_parses_algorithmic() {
let content = r#"\documentclass{article}
\usepackage{algorithmic}
\begin{document}
\begin{algorithmic}
\STATE $x \gets 1$
\end{algorithmic}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Center(_))),
"Expected Center from algorithmic");
}
#[test]
fn parser_parses_alltt() {
let content = r#"\documentclass{article}
\usepackage{alltt}
\begin{document}
\begin{alltt}
line 1
line 2
\end{alltt}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::CodeBlock(_))),
"Expected CodeBlock from alltt");
}
#[test]
fn parser_parses_text_symbols() {
let test_cases = [
("\\textunderscore", "_"),
("\\textdegree", "°"),
("\\textmu", "µ"),
("\\texteuro", "€"),
("\\textcent", "¢"),
("\\textyen", "¥"),
("\\textnumero", "№"),
("\\textohm", "Ω"),
("\\textbrokenbar", "¦"),
("\\textordfeminine", "ª"),
("\\textordmasculine", "º"),
];
for (cmd, expected) in &test_cases {
let mut parser = TexParser::new(cmd.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Text(t) if t == *expected)),
"Command {} should produce Text({})", cmd, expected);
}
}
#[test]
fn parser_parses_si() {
let content = r#"\documentclass{article}
\usepackage{siunitx}
\begin{document}
\SI{5}{\meter}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "SI" && args == &["5", "\\meter"])),
"Expected SI command with number and unit");
}
#[test]
fn parser_parses_si_unit() {
let content = r#"\documentclass{article}
\usepackage{siunitx}
\begin{document}
\si{\kilo\gram}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "si" && args == &["\\kilo\\gram"])),
"Expected si command with unit");
}
#[test]
fn parser_parses_num() {
let content = r#"\documentclass{article}
\usepackage{siunitx}
\begin{document}
\num{12345}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "num" && args == &["12345"])),
"Expected num command");
}
#[test]
fn parser_parses_sirange() {
let content = r#"\documentclass{article}
\usepackage{siunitx}
\begin{document}
\SIrange{0}{100}{\celsius}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "SIrange" && args.len() == 3)),
"Expected SIrange command with 3 args");
}
#[test]
fn parser_skips_sisetup() {
let content = r#"\documentclass{article}
\usepackage{siunitx}
\begin{document}
\sisetup{detect-all}
Text.
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(!elements.iter().any(|e| matches!(e, TexElement::Text(t) if t.contains("sisetup") || t.contains("detect"))),
"\\sisetup should be consumed");
}
#[test]
fn parser_parses_verb() {
let content = r#"\documentclass{article}
\begin{document}
Use \verb|printf("hello")| here.
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::CodeBlock(t) if t == "printf(\"hello\")")),
"Expected CodeBlock with verbatim content");
}
#[test]
fn parser_parses_verb_bang_delim() {
let content = r#"\documentclass{article}
\begin{document}
\verb!code with |pipe|!
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::CodeBlock(t) if t.contains("pipe"))),
"Expected CodeBlock with verbatim content using ! delimiter");
}
#[test]
fn parser_parses_verb_star() {
let content = r#"\documentclass{article}
\begin{document}
\verb*|a b c|
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::CodeBlock(t) if t == "a b c")),
"Expected CodeBlock from \\verb*");
}
#[test]
fn parser_parses_lstinline() {
let content = r#"\documentclass{article}
\begin{document}
Use \lstinline|for(int i=0;i<n;i++)| here.
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::CodeBlock(t) if t.contains("for(int"))),
"Expected CodeBlock from \\lstinline");
}
#[test]
fn parser_parses_smash() {
let content = r#"\smash{x}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "smash" && args == &["x"])),
"Expected smash command with content");
}
#[test]
fn parser_parses_nolinkurl() {
let content = r#"\documentclass{article}
\begin{document}
\nolinkurl{https://example.com}
\end{document}"#;
let mut parser = TexParser::new(content.to_string());
let elements = parser.parse();
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, args } if name == "nolinkurl" && args == &["https://example.com"])),
"Expected nolinkurl command");
}
}
#[cfg(test)]
mod text_coverage_tests {
use super::{TexElement, TexParser};
fn parse_body(src: &str) -> Vec<TexElement> {
let doc = format!(r#"\begin{{document}}{src}\end{{document}}"#);
let mut parser = TexParser::new(doc);
parser.parse()
}
fn text_of(src: &str) -> String {
let mut out = String::new();
for e in parse_body(src) {
if let TexElement::Text(t) = e {
out.push_str(&t);
}
}
out
}
#[test]
fn escaped_special_characters_render_literally() {
assert_eq!(text_of(r#"100\% \& \$5"#), "100% & $5");
assert_eq!(text_of(r#"\#3 \_x"#), "#3 _x");
assert_eq!(text_of(r#"\{braces\}"#), "{braces}");
}
#[test]
fn escaped_percent_does_not_start_a_comment() {
assert_eq!(text_of(r#"100\% done"#), "100% done");
}
#[test]
fn escaped_dollar_does_not_open_math() {
assert_eq!(text_of(r#"costs \$5 total"#), "costs $5 total");
}
#[test]
fn attached_text_accents_compose() {
assert_eq!(text_of(r#"caf\'e"#), "café");
assert_eq!(text_of(r#"Schr\"odinger"#), "Schrödinger");
assert_eq!(text_of(r#"jalape\~no"#), "jalapeño");
}
#[test]
fn braced_text_accents_compose() {
assert_eq!(text_of(r#"G\"{o}del"#), "Gödel");
assert_eq!(text_of(r#"P\'{e}ter"#), "Péter");
assert_eq!(text_of(r#"Fran\c{c}ois"#), "François");
assert_eq!(text_of(r#"\v{S}uster\v{s}i\v{c}"#), "Šusteršič");
}
#[test]
fn dotless_i_inside_accent_argument() {
assert_eq!(text_of(r#"na\"{\i}ve"#), "naı\u{308}ve");
}
#[test]
fn uppercase_bases_compose() {
assert_eq!(text_of(r#"\AE lius \O dag"#), "Ælius Ødag");
}
#[test]
fn space_after_control_word_is_eaten() {
assert_eq!(text_of(r#"Stra\ss e"#), "Straße");
assert_eq!(text_of(r#"\LaTeX{} rocks"#), "LaTeX rocks");
}
#[test]
fn tilde_is_a_space_in_text_mode() {
assert_eq!(text_of("A~B"), "A B");
}
#[test]
fn adjacent_text_fragments_concatenate_without_spaces() {
assert_eq!(text_of(r#"jalape\~no"#), "jalapeño");
assert_eq!(text_of(r#"Stra\ss e"#), "Straße");
}
#[test]
fn cline_is_not_the_cedilla_accent() {
let elements = parse_body(r#"\cline{1-2}"#);
assert!(elements.iter().any(|e| matches!(e, TexElement::Command { name, .. } if name == "cline")));
}
#[test]
fn thanks_becomes_a_footnote() {
let elements = parse_body(r#"\thanks{Supported by NSFC}"#);
assert!(elements
.iter()
.any(|e| matches!(e, TexElement::Footnote { text } if text == "Supported by NSFC")));
}
#[test]
fn case_conversion_commands() {
assert_eq!(text_of(r#"\MakeUppercase{abc}d"#), "ABCd");
assert_eq!(text_of(r#"\MakeLowercase{ABC}d"#), "abcd");
}
#[test]
fn empty_group_terminates_command_scope() {
assert_eq!(text_of(r#"\LaTeX{} rocks"#), "LaTeX rocks");
assert_eq!(text_of(r#"{x}y"#), "xy");
}
#[test]
fn euro_symbol() {
assert_eq!(text_of(r#"5 \euro"#), "5 €");
}
}
#[cfg(test)]
mod document_construct_tests {
use super::{MathLineKind, TexElement, TexParser};
fn parse_body(src: &str) -> Vec<TexElement> {
let doc = format!(r#"\begin{{document}}{src}\end{{document}}"#);
let mut parser = TexParser::new(doc);
parser.parse()
}
#[test]
fn longtable_parses_as_table() {
let elements = parse_body(r#"\begin{longtable}{ll}a & b\\ c & d\end{longtable}"#);
let table = elements.iter().find_map(|e| match e {
TexElement::Table(t) => Some(t),
_ => None,
});
let table = table.expect("longtable must produce a Table");
assert_eq!(table.rows.len(), 2);
assert_eq!(table.rows[0].cells, vec!["a", "b"]);
assert_eq!(table.rows[1].cells, vec!["c", "d"]);
}
#[test]
fn eqnarray_lines_end_at_own_marker() {
let elements = parse_body(r#"\begin{eqnarray} a &=& b \\ c &=& d \end{eqnarray}"#);
assert!(elements.iter().any(|e| matches!(
e,
TexElement::MathLines { lines, kind: MathLineKind::Align }
if lines.len() == 2 && lines[0].contains('a')
)));
}
#[test]
fn split_and_aligned_are_math_lines() {
for env in ["split", "aligned"] {
let src = format!(r#"\begin{{{env}}} a &= b \\ &= c \end{{{env}}}"#);
let elements = parse_body(&src);
assert!(
elements
.iter()
.any(|e| matches!(e, TexElement::MathLines { lines, .. } if lines.len() == 2)),
"{env} must parse as math lines, got {elements:?}"
);
}
}
#[test]
fn glossary_terms_render_from_definitions() {
let elements = parse_body(
r#"\newacronym{cpu}{CPU}{Central Processing Unit} The \gls{cpu} works."#,
);
let mut text = String::new();
for e in &elements {
if let TexElement::Text(t) = e {
text.push_str(t);
}
}
assert!(text.contains("The CPU works"), "got: {text}");
assert!(!text.contains("Central Processing Unit The"), "definition leaked: {text}");
}
#[test]
fn acronym_variants_render() {
let elements = parse_body(
r#"\newacronym{ram}{RAM}{Random Access Memory} \acrshort{ram} \acrlong{ram} \acrfull{ram} \Gls{ram}"#,
);
let mut text = String::new();
for e in &elements {
if let TexElement::Text(t) = e {
text.push_str(t);
text.push(' ');
}
}
assert!(text.contains("RAM"), "{text}");
assert!(text.contains("Random Access Memory"), "{text}");
assert!(text.contains("Random Access Memory (RAM)"), "{text}");
}
#[test]
fn glossary_entry_name_is_display_form() {
let elements = parse_body(
r#"\newglossaryentry{ml}{name=ML,description={Machine Learning}} See \gls{ml}."#,
);
let mut text = String::new();
for e in &elements {
if let TexElement::Text(t) = e {
text.push_str(t);
}
}
assert!(text.contains("See ML."), "got: {text}");
assert!(!text.contains("description="), "options leaked: {text}");
}
#[test]
fn texorpdfstring_keeps_tex_form_in_titles() {
let elements = parse_body(r#"\section{Intro\texorpdfstring{~x}{ y}}"#);
assert!(elements.iter().any(|e| matches!(
e,
TexElement::Section { title, .. } if title == "Intro x"
)));
}
#[test]
fn todo_notes_are_consumed() {
let elements = parse_body(r#"\todo{fix this} done"#);
let mut text = String::new();
for e in &elements {
if let TexElement::Text(t) = e {
text.push_str(t);
}
}
assert_eq!(text.trim(), "done");
}
#[test]
fn footref_is_a_reference() {
let elements = parse_body(r#"text\footref{fn:1} more"#);
assert!(
elements
.iter()
.any(|e| matches!(e, TexElement::Ref { key } if key == "fn:1")),
"got {elements:?}"
);
}
}