use muskitty_css_parser::{
parse_a_blocks_contents, parse_a_comma_separated_list_of_component_values,
parse_a_component_value, parse_a_declaration, parse_a_list_of_component_values, parse_a_rule,
parse_a_stylesheet, parse_a_stylesheets_contents, ComponentValue, Rule, Token,
};
#[test]
fn parse_a_stylesheet_simple() {
let ss = parse_a_stylesheet("a { color: red; }");
assert_eq!(ss.rules.len(), 1);
assert!(matches!(ss.rules[0], Rule::QualifiedRule(_)));
}
#[test]
fn parse_a_stylesheets_contents_returns_vec() {
let rules = parse_a_stylesheets_contents("a {} b {}");
assert_eq!(rules.len(), 2);
for r in &rules {
assert!(matches!(r, Rule::QualifiedRule(_)));
}
}
#[test]
fn parse_a_blocks_contents_basic() {
let bc = parse_a_blocks_contents("color: red; font: 16px;");
assert_eq!(bc.rules.len(), 1);
match &bc.rules[0] {
Rule::Declarations(decls) => {
assert_eq!(decls.len(), 2);
assert_eq!(decls[0].name, "color");
assert_eq!(decls[1].name, "font");
}
other => panic!("expected Rule::Declarations, got {other:?}"),
}
}
#[test]
fn parse_a_rule_at_rule() {
let rule = parse_a_rule("@media print {}");
assert!(matches!(rule, Some(Rule::AtRule(_))));
if let Some(Rule::AtRule(at)) = rule {
assert_eq!(at.name, "media");
assert!(at.declarations.is_some() || at.child_rules.is_some());
}
}
#[test]
fn parse_a_rule_qualified_rule() {
let rule = parse_a_rule("a {}");
assert!(matches!(rule, Some(Rule::QualifiedRule(_))));
}
#[test]
fn parse_a_rule_eof_returns_none() {
let rule = parse_a_rule("");
assert!(rule.is_none());
}
#[test]
fn parse_a_rule_trailing_garbage_returns_none() {
let rule = parse_a_rule("a {} b");
assert!(rule.is_none());
}
#[test]
fn parse_a_declaration_simple() {
let decl = parse_a_declaration("color: red");
assert!(decl.is_some());
let decl = decl.unwrap();
assert_eq!(decl.name, "color");
assert!(!decl.important);
}
#[test]
fn parse_a_component_value_simple() {
let cv = parse_a_component_value("red");
assert!(cv.is_some());
match cv.unwrap() {
ComponentValue::PreservedToken(Token::Ident(name)) => {
assert_eq!(name, "red");
}
other => panic!("expected PreservedToken(Ident(\"red\")), got {other:?}"),
}
}
#[test]
fn parse_a_comma_separated_list_basic() {
let groups = parse_a_comma_separated_list_of_component_values("a, b, c");
assert_eq!(groups.len(), 3);
assert_eq!(groups[0].len(), 1);
assert!(matches!(
groups[0][0],
ComponentValue::PreservedToken(Token::Ident(_))
));
for (i, g) in groups[1..].iter().enumerate() {
assert_eq!(g.len(), 2, "group {} should have ws + ident", i + 1);
assert!(matches!(
g[0],
ComponentValue::PreservedToken(Token::Whitespace)
));
match &g[1] {
ComponentValue::PreservedToken(Token::Ident(name)) => {
let expected = match i {
0 => "b",
1 => "c",
_ => unreachable!(),
};
assert_eq!(name, expected);
}
other => panic!("group {}: expected Ident, got {other:?}", i + 1),
}
}
}
#[test]
fn parse_a_list_of_component_values_basic() {
let list = parse_a_list_of_component_values("a b c");
assert_eq!(list.len(), 5);
assert!(matches!(
list[0],
ComponentValue::PreservedToken(Token::Ident(_))
));
}