////////////////////////////
// Automatically Generated//
////////////////////////////
use crate::logger::messages::Message;
use crate::parsing::lexer::lex;
use crate::parsing::lexer::lex_tokens::LexToken;
use crate::parsing::parser::parse;
use crate::parsing::parser::parsed_statement::ParsedStatement;
use crate::span::Span;

fn ignore_error(_msg: Message, _: Span) {
}

fn panic_on_error(msg: Message, _: Span) {
    std::panic::panic_any(msg.stringify());
}
#[test]
fn integration_empty_class_declaration() {
    let script = "class Foo {}";
    let lexed_tokens = lex(script, &mut panic_on_error);
    println!("{}", serde_json::to_string(&lexed_tokens).unwrap());
    let expected_tokens: Vec<LexToken> =
        serde_json::from_str(r#"[
    {
        "token_type": "ClassKeyword",
        "span": {
            "start": 0,
            "end": 5
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 5,
            "end": 6
        }
    },
    {
        "token_type": {
            "Identifier": "Foo"
        },
        "span": {
            "start": 6,
            "end": 9
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 9,
            "end": 10
        }
    },
    {
        "token_type": "OpenCurlyBracket",
        "span": {
            "start": 10,
            "end": 11
        }
    },
    {
        "token_type": "CloseCurlyBracket",
        "span": {
            "start": 11,
            "end": 12
        }
    },
    {
        "token_type": "EndOfFile",
        "span": {
            "start": 12,
            "end": 12
        }
    }
]"#).unwrap();
    assert_eq!(lexed_tokens, expected_tokens);

    let parsed_tree = parse(lexed_tokens, &mut panic_on_error);
    println!("{}", serde_json::to_string(&parsed_tree).unwrap());
    let expected_tree: Box<ParsedStatement> =
        serde_json::from_str(r#"{
    "Script": {
        "statements": [
            {
                "ClassDeclaration": {
                    "modifiers": 0,
                    "name": "Foo",
                    "inherits": [],
                    "statements": []
                }
            }
        ]
    }
}"#).unwrap();
    assert_eq!(parsed_tree, expected_tree);
}
// A substring of a script should never panic, even though it might be completely invalid.
#[test]
fn integration_empty_class_declaration_substring() {
    let mut script = "class Foo {}".to_string();
    for _ in 0..script.len() {
        script.pop();
        let lexed_tokens = lex(script.as_str(), &mut ignore_error);
        let _parsed_tree = parse(lexed_tokens, &mut ignore_error);
    }

}