////////////////////////////
// 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_multiple_inheritance_class() {
    let script = "class Foo : Zom, Aar, Bar {}";
    let lexed_tokens = lex(script, &mut panic_on_error);
    println!("Lexed tokens JSON: {}", 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": "Colon",
        "span": {
            "start": 10,
            "end": 11
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 11,
            "end": 12
        }
    },
    {
        "token_type": {
            "Identifier": "Zom"
        },
        "span": {
            "start": 12,
            "end": 15
        }
    },
    {
        "token_type": "Comma",
        "span": {
            "start": 15,
            "end": 16
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 16,
            "end": 17
        }
    },
    {
        "token_type": {
            "Identifier": "Aar"
        },
        "span": {
            "start": 17,
            "end": 20
        }
    },
    {
        "token_type": "Comma",
        "span": {
            "start": 20,
            "end": 21
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 21,
            "end": 22
        }
    },
    {
        "token_type": {
            "Identifier": "Bar"
        },
        "span": {
            "start": 22,
            "end": 25
        }
    },
    {
        "token_type": "WhiteSpace",
        "span": {
            "start": 25,
            "end": 26
        }
    },
    {
        "token_type": "OpenCurlyBracket",
        "span": {
            "start": 26,
            "end": 27
        }
    },
    {
        "token_type": "CloseCurlyBracket",
        "span": {
            "start": 27,
            "end": 28
        }
    },
    {
        "token_type": "EndOfFile",
        "span": {
            "start": 28,
            "end": 28
        }
    }
]"#).unwrap();
    assert_eq!(lexed_tokens, expected_tokens);

    let parsed_tree = parse(lexed_tokens, &mut panic_on_error);
    println!("Parsed Tree JSON: {}", serde_json::to_string(&parsed_tree).unwrap());
    let expected_tree: Box<ParsedStatement> =
        serde_json::from_str(r#"{
  "data": {
    "Script": {
      "statements": [
        {
          "data": {
            "ClassDeclaration": {
              "modifiers": 0,
              "name": "Foo",
              "inherits": [
                "Zom",
                "Aar",
                "Bar"
              ],
              "statements": []
            }
          },
          "span": {
            "start": 0,
            "end": 28
          }
        }
      ]
    }
  },
  "span": {
    "start": 0,
    "end": 28
  }
}
"#).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_multiple_inheritance_class_substring() {
    let mut script = "class Foo : Zom, Aar, Bar {}".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);
    }

}