jutty/en
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Expand test coverage

Browse source
This commit is contained in:
Juno Takano 2026-01-10 05:42:36 -03:00
commit 5958f1551b
27 changed files with 593 additions and 109 deletions
Download patch file Download diff file Expand all files Collapse all files

55
src/syntax/content/parser/token/anchor.rs
View file

@ -45,15 +45,22 @@ impl std::fmt::Display for Anchor {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
use crate::dev::wrap;
let wrapped_text = wrap(&self.text);
let display_text = if wrapped_text.is_empty() {
"<empty>"
} else {
wrapped_text.as_str()
};
let display_destination = match self.destination {
Some(ref destination) => {
if destination.is_empty() {
"<empty>"
String::from("<empty>")
} else {
destination
format!("{destination:?}")
}
},
None => "<unknown>",
None => String::from("<unknown>"),
};
let mut tail = String::default();
@ -68,13 +75,7 @@ impl std::fmt::Display for Anchor {
tail.push_str(" +External");
}
write!(
f,
"Anchor {:?} -> {:?}{}",
wrap(&self.text),
display_destination,
tail
)
write!(f, "Anchor {display_text} -> {display_destination}{tail}")
}
}
@ -107,6 +108,8 @@ impl Anchor {
#[cfg(test)]
mod tests {
use crate::syntax::content::parser::token::Token;
use super::*;
#[test]
@ -133,4 +136,36 @@ mod tests {
let anchor = Anchor::default();
drop(anchor.render());
}
#[test]
fn token_display() {
let mut anchor = Anchor::default();
assert_eq!(
format!("{}", Token::Anchor(anchor.clone())),
"Tk:Anchor <empty> -> <unknown>",
);
anchor.text = String::from("FsJAt RTggA");
assert_eq!(
format!("{}", Token::Anchor(anchor.clone())),
"Tk:Anchor 'FsJAt RTggA' -> <unknown>",
);
anchor.text = String::from("wPVo1 0OmYm");
anchor.destination = Some(String::from("M1UEp 1gbfr"));
assert_eq!(
format!("{}", Token::Anchor(anchor.clone())),
r#"Tk:Anchor 'wPVo1 0OmYm' -> "M1UEp 1gbfr""#,
);
anchor.balanced = true;
anchor.leading = true;
anchor.external = true;
assert_eq!(
format!("{}", Token::Anchor(anchor.clone())),
"Tk:Anchor 'wPVo1 0OmYm' -> \"M1UEp 1gbfr\" \
+Leading +Balanced +External",
);
}
}

14
src/syntax/content/parser/token/bold.rs
View file

@ -40,6 +40,8 @@ impl std::fmt::Display for Bold {
#[cfg(test)]
mod tests {
use crate::syntax::content::parser::token::Token;
use super::*;
#[test]
@ -58,4 +60,16 @@ mod tests {
fn lex() {
Bold::lex(&Lexeme::default());
}
#[test]
fn token_display() {
let mut bold = Bold::new(true);
assert_eq!(format!("{}", Token::Bold(bold.clone())), "Tk:Bold [open]");
bold.open = false;
assert_eq!(
format!("{}", Token::Bold(bold.clone())),
"Tk:Bold [closed]"
);
}
}

17
src/syntax/content/parser/token/checkbox.rs
View file

@ -44,6 +44,8 @@ impl std::fmt::Display for CheckBox {
#[cfg(test)]
mod tests {
use crate::syntax::content::parser::token::Token;
use super::*;
#[test]
@ -54,4 +56,19 @@ mod tests {
let code_closed = CheckBox::new(false);
assert_eq!(code_closed.render(), r#"<input type="checkbox"/>"#);
}
#[test]
fn token_display() {
let mut checkbox = CheckBox::new(true);
assert_eq!(
format!("{}", Token::CheckBox(checkbox.clone())),
"Tk:CheckBox [checked]"
);
checkbox.checked = false;
assert_eq!(
format!("{}", Token::CheckBox(checkbox.clone())),
"Tk:CheckBox [empty]"
);
}
}

14
src/syntax/content/parser/token/code.rs
View file

@ -40,6 +40,8 @@ impl std::fmt::Display for Code {
#[cfg(test)]
mod tests {
use crate::syntax::content::parser::token::Token;
use super::*;
#[test]
@ -58,4 +60,16 @@ mod tests {
fn lex() {
Code::lex(&Lexeme::default());
}
#[test]
fn token_display() {
let mut code = Code::new(true);
assert_eq!(format!("{}", Token::Code(code.clone())), "Tk:Code [open]");
code.open = false;
assert_eq!(
format!("{}", Token::Code(code.clone())),
"Tk:Code [closed]"
);
}
}

11
src/syntax/content/parser/token/header.rs
View file

@ -191,6 +191,8 @@ impl Display for Level {
#[cfg(test)]
mod tests {
use crate::syntax::content::parser::token::Token;
use super::*;
#[test]
@ -285,4 +287,13 @@ mod tests {
header.render();
}
#[test]
fn token_display() {
let header = Header::from_u8(2, false, None);
assert_eq!(
format!("{}", Token::Header(header)),
"Tk:Header [closed L2]"
);
}
}

43
src/syntax/content/parser/token/item.rs
View file

@ -43,3 +43,46 @@ impl std::fmt::Display for Item {
)
}
}
#[cfg(test)]
mod tests {
use crate::syntax::content::parser::token::Token;
use super::*;
#[test]
#[should_panic(
expected = "Items should only be rendered by a list's render method"
)]
fn render() {
let item = Item::new("aCNuZwwzrt", None);
item.render();
}
#[test]
fn probe() {
let lexeme = Lexeme::new("bOa", "2R6", "4Mp");
assert!(!Item::probe(&lexeme));
}
#[test]
#[should_panic(expected = "Attempt to lex an item directly from a lexeme")]
fn lex() {
let lexeme = Lexeme::new("8kbX", "Qzqu", "iDpg");
Item::lex(&lexeme);
}
#[test]
fn token_display() {
let mut item = Item::new("dRMy4", Some(4));
assert_eq!(
format!("{}", Token::Item(item.clone())),
"Tk:Item [D4] dRMy4"
);
item.depth = None;
assert_eq!(
format!("{}", Token::Item(item.clone())),
"Tk:Item [<unknown>] dRMy4"
);
}
}

13
src/syntax/content/parser/token/linebreak.rs
View file

@ -24,3 +24,16 @@ impl std::fmt::Display for LineBreak {
write!(f, "LineBreak")
}
}
#[cfg(test)]
mod tests {
use crate::syntax::content::parser::token::Token;
use super::*;
#[test]
fn token_display() {
let linebreak = LineBreak::default();
assert_eq!(format!("{}", Token::LineBreak(linebreak)), "Tk:LineBreak");
}
}

18
src/syntax/content/parser/token/list.rs
View file

@ -90,6 +90,8 @@ impl std::fmt::Display for List {
#[cfg(test)]
mod tests {
use crate::syntax::content::parser::token::Token;
use super::*;
#[test]
@ -164,4 +166,20 @@ mod tests {
</ul>\n\n"
);
}
#[test]
fn token_display() {
let list = List::new(false);
assert_eq!(
format!("{}", Token::List(list.clone())),
"Tk:List [0 unordered items]"
);
}
#[test]
#[should_panic(expected = "Attempt to lex a List directly from a lexeme")]
fn lex() {
let lexeme = Lexeme::new("SL6PX", "6xsNB", "oeAHa");
List::lex(&lexeme);
}
}

24
src/syntax/content/parser/token/literal.rs
View file

@ -26,3 +26,27 @@ impl std::fmt::Display for Literal {
write!(f, "Literal {}", crate::dev::wrap(&self.text))
}
}
#[cfg(test)]
mod tests {
use crate::syntax::content::parser::token::Token;
use super::*;
#[test]
fn token_display() {
let mut literal = Literal {
text: String::from("MYpDT"),
};
assert_eq!(
format!("{}", Token::Literal(literal.clone())),
"Tk:Literal MYpDT"
);
literal.text = String::from("TjY02");
assert_eq!(
format!("{}", Token::Literal(literal.clone())),
"Tk:Literal TjY02"
);
}
}

17
src/syntax/content/parser/token/oblique.rs
View file

@ -40,6 +40,8 @@ impl std::fmt::Display for Oblique {
#[cfg(test)]
mod tests {
use crate::syntax::content::parser::token::Token;
use super::*;
#[test]
@ -58,4 +60,19 @@ mod tests {
fn lex() {
Oblique::lex(&Lexeme::default());
}
#[test]
fn token_display() {
let mut oblique = Oblique::new(true);
assert_eq!(
format!("{}", Token::Oblique(oblique.clone())),
"Tk:Oblique [open]"
);
oblique.open = false;
assert_eq!(
format!("{}", Token::Oblique(oblique.clone())),
"Tk:Oblique [closed]"
);
}
}

23
src/syntax/content/parser/token/paragraph.rs
View file

@ -58,6 +58,8 @@ impl std::fmt::Display for Paragraph {
#[cfg(test)]
mod tests {
use crate::syntax::content::parser::token::Token;
use super::*;
#[test]
@ -74,4 +76,25 @@ mod tests {
let p = Paragraph::lex(&Lexeme::default());
drop(p.render());
}
#[test]
fn token_display() {
let mut paragraph = Paragraph::new(true);
assert_eq!(
format!("{}", Token::Paragraph(paragraph.clone())),
"Tk:Paragraph [open]"
);
paragraph.open = Some(false);
assert_eq!(
format!("{}", Token::Paragraph(paragraph.clone())),
"Tk:Paragraph [closed]"
);
paragraph.open = None;
assert_eq!(
format!("{}", Token::Paragraph(paragraph.clone())),
"Tk:Paragraph [unknown]"
);
}
}

23
src/syntax/content/parser/token/preformat.rs
View file

@ -50,6 +50,8 @@ impl Parseable for PreFormat {
#[cfg(test)]
mod tests {
use crate::syntax::content::parser::token::Token;
use super::*;
#[test]
@ -72,4 +74,25 @@ mod tests {
let from_non_empty_lexeme = PreFormat::lex(&Lexeme::default());
from_non_empty_lexeme.render();
}
#[test]
fn token_display() {
let mut preformat = PreFormat::new(true);
assert_eq!(
format!("{}", Token::PreFormat(preformat.clone())),
"Tk:PreFormat [open]"
);
preformat.open = Some(false);
assert_eq!(
format!("{}", Token::PreFormat(preformat.clone())),
"Tk:PreFormat [closed]"
);
preformat.open = None;
assert_eq!(
format!("{}", Token::PreFormat(preformat.clone())),
"Tk:PreFormat [unknown]"
);
}
}

84
src/syntax/content/parser/token/span.rs
View file

@ -1,85 +1 @@
use crate::syntax::content::{Parseable, parser::lexeme::Lexeme};
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Span {
open: Option<bool>,
}
impl Span {
pub fn new(open: bool) -> Span {
Span { open: Some(open) }
}
}
impl Parseable for Span {
fn probe(_lexeme: &Lexeme) -> bool {
// there is no lexeme for span
false
}
fn lex(_lexeme: &Lexeme) -> Span {
Span { open: None }
}
fn render(&self) -> String {
if let Some(open) = self.open {
if open {
"<span>".to_owned()
} else {
"</span>".to_owned()
}
} else {
panic!("Attempt to render a span tag while open state is unknown")
}
}
}
impl std::fmt::Display for Span {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let display_open_state = match self.open {
Some(ref open_state) => {
if *open_state {
"open"
} else {
"closed"
}
},
None => "unknown",
};
write!(f, "Span [{display_open_state}]")
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn probe() {
assert!(!Span::probe(&Lexeme::default()));
}
#[test]
fn lex() {
let span = Span::lex(&Lexeme::default());
assert!(span.open.is_none());
}
#[test]
fn render() {
let open_span = Span::new(true);
assert_eq!(open_span.render(), "<span>");
let closed_span = Span::new(false);
assert_eq!(closed_span.render(), "</span>");
}
#[test]
#[should_panic(
expected = "Attempt to render a span tag while open state is unknown"
)]
fn render_unknown_open_state() {
let open_span = Span::lex(&Lexeme::default());
drop(open_span.render());
}
}

17
src/syntax/content/parser/token/strike.rs
View file

@ -37,6 +37,8 @@ impl std::fmt::Display for Strike {
#[cfg(test)]
mod tests {
use crate::syntax::content::parser::token::Token;
use super::*;
#[test]
@ -55,4 +57,19 @@ mod tests {
fn lex() {
Strike::lex(&Lexeme::default());
}
#[test]
fn token_display() {
let mut strike = Strike::new(true);
assert_eq!(
format!("{}", Token::Strike(strike.clone())),
"Tk:Strike [open]"
);
strike.open = false;
assert_eq!(
format!("{}", Token::Strike(strike.clone())),
"Tk:Strike [closed]"
);
}
}

17
src/syntax/content/parser/token/underline.rs
View file

@ -40,6 +40,8 @@ impl std::fmt::Display for Underline {
#[cfg(test)]
mod tests {
use crate::syntax::content::parser::token::Token;
use super::*;
#[test]
@ -58,4 +60,19 @@ mod tests {
fn lex() {
Underline::lex(&Lexeme::default());
}
#[test]
fn token_display() {
let mut underline = Underline::new(true);
assert_eq!(
format!("{}", Token::Underline(underline.clone())),
"Tk:Underline [open]"
);
underline.open = false;
assert_eq!(
format!("{}", Token::Underline(underline.clone())),
"Tk:Underline [closed]"
);
}
}