fuzz/fuzz_targets/cssparser.rs

#![no_main]

use cssparser::*;

const DEBUG: bool = false;

fn parse_and_serialize(input: &str, preserving_comments: bool) -> String {
    let mut input = ParserInput::new(input);
    let mut parser = Parser::new(&mut input);
    let mut serialization = String::new();
    let result = do_parse_and_serialize(
        &mut parser,
        preserving_comments,
        TokenSerializationType::nothing(),
        &mut serialization,
        0,
    );
    if result.is_err() {
        return String::new();
    }
    serialization
}

fn do_parse_and_serialize<'i>(
    input: &mut Parser<'i, '_>,
    preserving_comments: bool,
    mut previous_token_type: TokenSerializationType,
    serialization: &mut String,
    indent_level: usize,
) -> Result<(), ParseError<'i, ()>> {
    loop {
        let token = if preserving_comments {
            input.next_including_whitespace_and_comments()
        } else {
            input.next_including_whitespace()
        };
        let token = match token {
            Ok(token) => token,
            Err(..) => break,
        };
        if DEBUG {
            for _ in 0..indent_level {
                print!(" ");
            }
            println!("{:?}", token);
        }
        if token.is_parse_error() {
            let token = token.clone();
            return Err(input.new_unexpected_token_error(token))
        }
        let token_type = token.serialization_type();
        if previous_token_type.needs_separator_when_before(token_type) {
            serialization.push_str("/**/");
        }
        previous_token_type = token_type;
        token.to_css(serialization).unwrap();
        let closing_token = match token {
            Token::Function(_) | Token::ParenthesisBlock => Token::CloseParenthesis,
            Token::SquareBracketBlock => Token::CloseSquareBracket,
            Token::CurlyBracketBlock => Token::CloseCurlyBracket,
            _ => continue,
        };

        input.parse_nested_block(|input| -> Result<_, ParseError<()>> {
            do_parse_and_serialize(input, preserving_comments, previous_token_type, serialization, indent_level + 1)
        })?;

        closing_token.to_css(serialization).unwrap();
    }
    Ok(())
}

fn fuzz(data: &str, preserving_comments: bool) {
    let serialization = parse_and_serialize(data, preserving_comments);
    let reserialization = parse_and_serialize(&serialization, preserving_comments);
    if DEBUG {
        println!("IN: {:?}", serialization);
        println!("OUT: {:?}", reserialization);
    }
    // TODO: This should ideally pass, but it doesn't for numbers near our
    // precision limits, so parsing e.g., 9999995e-45 generates a serialization
    // of 10e-39 because of dtoa rounding, and parsing _that_ generates a
    // serialization of 1e-38.
    //
    // assert_eq!(
    //     serialization, reserialization,
    //     "Serialization should be idempotent"
    // );
}

libfuzzer_sys::fuzz_target!(|data: &str| {
    fuzz(data, false);
    // TODO(emilio): Serialization when preserving comments is not idempotent.
    // But in browsers we never preserve comments so that's ok...
    // fuzz(data, true);
});