ocpi-tariffs 0.46.1

use crate::{
    json::{PathNode, Value, ValueKind},
    test,
};

use super::{Event, ObjectKind, Parser};

#[test]
fn should_emit_events_for_object_with_single_field() {
    const JSON: &str = r#"{
    "field_a": 404
}"#;

    test::setup();

    let mut parser = Parser::new(JSON);
    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Open {
            kind: ObjectKind::Object,
            parent_path
        }
         => parent_path
    );
    assert_matches!(*path, PathNode::Root);

    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Element {
            kind: ValueKind::Number,
            parent_path
        }
         => parent_path
    );

    assert_eq!(*path, "$.field_a");
}

#[test]
fn should_emit_events_for_object_with_two_fields() {
    const JSON: &str = r#"{
    "field_a": 404,
    "field_b": "name"
}"#;

    test::setup();

    let mut parser = Parser::new(JSON);
    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Open {
            kind: ObjectKind::Object,
            parent_path
        }
         => parent_path
    );
    assert_matches!(*path, PathNode::Root);

    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Element {
            kind: ValueKind::Number,
            parent_path
        }
         => parent_path
    );

    assert_eq!(*path, "$.field_a");

    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Element {
            kind: ValueKind::String,
            parent_path
        }
         => parent_path
    );

    assert_eq!(*path, "$.field_b");
}

#[test]
fn should_emit_events_for_object_with_nested_fields() {
    const JSON: &str = r#"{
    "field_a": 404,
    "field_b": {
        "field_c": "name"
    }
}"#;

    test::setup();

    let mut parser = Parser::new(JSON);
    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Open {
            kind: ObjectKind::Object,
            parent_path
        }
         => parent_path
    );
    assert_matches!(*path, PathNode::Root);

    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Element {
            kind: ValueKind::Number,
            parent_path
        }
         => parent_path
    );

    assert_eq!(*path, "$.field_a");

    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Open {
            kind: ObjectKind::Object,
            parent_path
        }
         => parent_path
    );
    assert_eq!(*path, "$.field_b");

    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Element {
            kind: ValueKind::String,
            parent_path
        }
         => parent_path
    );

    assert_eq!(*path, "$.field_b.field_c");
}

#[test]
fn should_emit_events_for_array_with_single_field() {
    const JSON: &str = r#"["field_a"]"#;

    test::setup();

    let mut parser = Parser::new(JSON);
    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Open {
            kind: ObjectKind::Array,
            parent_path
        }
         => parent_path
    );
    assert_matches!(*path, PathNode::Root);

    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Element {
            kind: ValueKind::String,
            parent_path
        }
         => parent_path
    );

    assert_eq!(*path, "$.0");
}

#[test]
fn should_emit_events_for_array_with_two_fields() {
    const JSON: &str = r#"{
    "field_a": 404,
    "field_b": "name"
}"#;

    test::setup();

    let mut parser = Parser::new(JSON);
    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Open {
            kind: ObjectKind::Object,
            parent_path
        }
         => parent_path
    );
    assert_matches!(*path, PathNode::Root);

    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Element {
            kind: ValueKind::Number,
            parent_path
        }
         => parent_path
    );

    assert_eq!(*path, "$.field_a");

    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Element {
            kind: ValueKind::String,
            parent_path
        }
         => parent_path
    );

    assert_eq!(*path, "$.field_b");
}

#[test]
fn should_emit_events_for_array_with_nested_fields() {
    const JSON: &str = r#"{
    "field_a": 404,
    "field_b": {
        "field_c": "name"
    }
}"#;

    test::setup();

    let mut parser = Parser::new(JSON);
    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Open {
            kind: ObjectKind::Object,
            parent_path
        }
         => parent_path
    );
    assert_matches!(*path, PathNode::Root);

    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Element {
            kind: ValueKind::Number,
            parent_path
        }
         => parent_path
    );

    assert_eq!(*path, "$.field_a");

    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Open {
            kind: ObjectKind::Object,
            parent_path
        }
         => parent_path
    );
    assert_eq!(*path, "$.field_b");

    let event = parser.next().unwrap().unwrap();

    let path = assert_matches!(
        event,
        Event::Element {
            kind: ValueKind::String,
            parent_path
        }
         => parent_path
    );

    assert_eq!(*path, "$.field_b.field_c");
}

use assert_matches::assert_matches;

use super::{parse, test::spanned_json, ErrorKind, TokenType};

#[test]
fn should_err_on_array_1_true_without_comma_json() {
    const JSON: &str = "[1 true]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::BooleanTrue);
}

#[test]
fn should_err_on_array_colon_instead_of_comma_json() {
    const JSON: &str = r#"["": 1]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Colon);
}

#[test]
fn should_err_on_array_comma_after_close_json() {
    const JSON: &str = r#"[""],"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Comma);
}

#[test]
fn should_err_on_array_comma_and_number_json() {
    const JSON: &str = "[,1]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Comma);
}

#[test]
fn should_err_on_array_double_comma_json() {
    const JSON: &str = "[1,,2]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Comma);
}

#[test]
fn should_err_on_array_double_extra_comma_json() {
    const JSON: &str = r#"["x",,]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Comma);
}

#[test]
fn should_err_on_array_extra_close_json() {
    const JSON: &str = r#"["x"]]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::BracketClose);
}

#[test]
fn should_err_on_array_extra_comma_json() {
    const JSON: &str = r#"["",]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Comma);
}

#[test]
fn should_err_on_array_incomplete_json() {
    const JSON: &str = r#"["x""#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_array_incomplete_invalid_value_json() {
    const JSON: &str = "[x";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_array_inner_array_no_comma_json() {
    const JSON: &str = "[3[4]]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::BracketOpen);
}

#[test]
fn should_err_on_array_items_separated_by_semicolon_json() {
    const JSON: &str = "[1:2]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Colon);
}

#[test]
fn should_err_on_array_just_comma_json() {
    const JSON: &str = "[,]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Comma);
}

#[test]
fn should_err_on_array_missing_value_json() {
    const JSON: &str = r#"[   , ""]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Comma);
}

#[test]
fn should_err_on_array_newlines_unclosed_json() {
    const JSON: &str = r#"["a",
4
,1,"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_array_number_and_comma_json() {
    const JSON: &str = "[1,]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Comma);
}

#[test]
fn should_err_on_array_number_and_several_commas_json() {
    const JSON: &str = "[1,,]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Comma);
}

#[test]
fn should_err_on_array_spaces_vertical_tab_formfeed_json() {
    const JSON: &str = r#"["a"\f]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_array_unclosed_json() {
    const JSON: &str = r#"["""#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_array_unclosed_trailing_comma_json() {
    const JSON: &str = "[1,";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_array_unclosed_with_new_lines_json() {
    const JSON: &str = "[1,
1
,1";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_array_unclosed_with_object_inside_json() {
    const JSON: &str = "[{}";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_incomplete_false_json() {
    const JSON: &str = "[fals]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_incomplete_null_json() {
    const JSON: &str = "[nul]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_incomplete_true_json() {
    const JSON: &str = "[tru]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_number_plus_inf_json() {
    const JSON: &str = "[+Inf]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_number_1_000_json() {
    const JSON: &str = "[1 000.0]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Number);
}

#[test]
fn should_err_on_object_bad_value_json() {
    const JSON: &str = r#"["x", truth]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_object_bracket_key_json() {
    const JSON: &str = r#"{[: "x"}
"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::BracketOpen);
}

#[test]
fn should_err_on_object_comma_instead_of_colon_json() {
    const JSON: &str = r#"{"x", null}"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Comma);
}

#[test]
fn should_err_on_object_double_colon_json() {
    const JSON: &str = r#"{"x"::"b"}"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Colon);
}

#[test]
fn should_err_on_object_garbage_at_end_json() {
    const JSON: &str = r#"{"a":"a" 123}"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Number);
}

#[test]
fn should_err_on_object_key_with_single_quotes_json() {
    const JSON: &str = "{key: 'value'}";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Colon);
}

#[test]
fn should_err_on_object_missing_colon_json() {
    const JSON: &str = r#"{"a" b}"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::CurlyClose);
}

#[test]
fn should_err_on_object_missing_key_json() {
    const JSON: &str = r#"{:"b"}"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Colon);
}

#[test]
fn should_err_on_object_missing_semicolon_json() {
    const JSON: &str = r#"{"a" "b"}"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::String);
}

#[test]
fn should_err_on_object_missing_value_json() {
    const JSON: &str = r#"{"a":"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_object_no_min_colon_json() {
    const JSON: &str = r#"{"a""#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_object_non_string_key_json() {
    const JSON: &str = "{1:1}";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Number);
}

#[test]
fn should_err_on_object_non_string_key_but_huge_number_instead_json() {
    const JSON: &str = "{9999E9999:1}";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Number);
}

#[test]
fn should_err_on_object_repeated_null_null_json() {
    const JSON: &str = "{null:null,null:null}";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Null);
}

#[test]
fn should_err_on_object_several_trailing_commas_json() {
    const JSON: &str = r#"{"id":0,,,,,}"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Comma);
}

#[test]
fn should_err_on_object_single_quote_json() {
    const JSON: &str = "{'a':0}";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Colon);
}

#[test]
fn should_err_on_object_trailing_comma_json() {
    const JSON: &str = r#"{"id":0,}"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Comma);
}

#[test]
fn should_err_on_object_two_commas_in_a_row_json() {
    const JSON: &str = r#"{"a":"b",,"c":"d"}"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Comma);
}

#[test]
fn should_err_on_object_unquoted_key_json() {
    const JSON: &str = r#"{a: "b"}"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Colon);
}

#[test]
fn should_err_on_object_unterminated_min_value_json() {
    const JSON: &str = r#"{"a":"a"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_object_with_single_string_json() {
    const JSON: &str = r#"{ "foo" : "bar", "a" }"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::CurlyClose);
}

#[test]
fn should_err_on_single_space_json() {
    const JSON: &str = " ";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_string_1_surrogate_then_escape_json() {
    const JSON: &str = r#"["\uD800\"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_1_surrogate_then_escape_u_json() {
    const JSON: &str = r#"["\uD800\u"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_1_surrogate_then_escape_u1_json() {
    const JSON: &str = r#"["\uD800\u1"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_1_surrogate_then_escape_u1x_json() {
    const JSON: &str = r#"["\uD800\u1x"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_backslash_00_json() {
    const JSON: &str = r#"["\"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_escape_x_json() {
    const JSON: &str = r#"["\x00"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_escaped_backslash_bad_json() {
    const JSON: &str = r#"["\\\"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_escaped_ctrl_char_tab_json() {
    const JSON: &str = r#"["\	"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_escaped_emoji_json() {
    const JSON: &str = r#"["\🌀"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_incomplete_escape_json() {
    const JSON: &str = r#"["\"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_incomplete_escaped_character_json() {
    const JSON: &str = r#"["\u00A"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_incomplete_surrogate_json() {
    const JSON: &str = r#"["\uD834\uDd"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_incomplete_surrogate_escape_invalid_json() {
    const JSON: &str = r#"["\uD800\uD800\x"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_invalid_backslash_esc_json() {
    const JSON: &str = r#"["\a"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_invalid_unicode_escape_json() {
    const JSON: &str = r#"["\uqqqq"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_leading_uescaped_thinspace_json() {
    const JSON: &str = r#"[\u0020"asd"]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_no_quotes_with_bad_escape_json() {
    const JSON: &str = r"[\n]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_single_doublequote_json() {
    const JSON: &str = r#"""#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_single_quote_json() {
    const JSON: &str = "['single quote']";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_single_string_no_double_quotes_json() {
    const JSON: &str = "abc";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_string_start_escape_unclosed_json() {
    const JSON: &str = r#"["\"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_string_unicode_capitalu_json() {
    const JSON: &str = r#""\UA66D""#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_structure_array_with_extra_array_close_json() {
    const JSON: &str = "[1]]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::BracketClose);
}

#[test]
fn should_err_on_structure_array_with_unclosed_string_json() {
    const JSON: &str = r#"["asd]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_structure_ascii_min_unicode_min_identifier_json() {
    const JSON: &str = "aå";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_close_unopened_array_json() {
    const JSON: &str = "1]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::BracketClose);
}

#[test]
fn should_err_on_structure_comma_instead_of_closing_brace_json() {
    const JSON: &str = r#"{"x": true,"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_double_array_json() {
    const JSON: &str = "[][]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::BracketOpen);
}

#[test]
fn should_err_on_structure_end_array_json() {
    const JSON: &str = "]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::BracketClose);
}

#[test]
fn should_err_on_structure_lone_min_open_min_bracket_json() {
    const JSON: &str = "[";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_no_data_json() {
    const JSON: &str = "";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_object_followed_by_closing_object_json() {
    const JSON: &str = "{}}";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::CurlyClose);
}

#[test]
fn should_err_on_structure_object_unclosed_no_value_json() {
    const JSON: &str = r#"{"":"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_object_with_comment_json() {
    const JSON: &str = r#"{"a":/*comment*/"b"}"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_structure_object_with_trailing_garbage_json() {
    const JSON: &str = r#"{"a": true} "x""#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::String);
}

#[test]
fn should_err_on_structure_open_array_apostrophe_json() {
    const JSON: &str = "['";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_open_array_comma_json() {
    const JSON: &str = "[,";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Comma);
}

#[test]
fn should_err_on_structure_open_array_open_object_json() {
    const JSON: &str = "[{";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_open_array_open_string_json() {
    const JSON: &str = r#"["a"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_structure_open_array_string_json() {
    const JSON: &str = r#"["a""#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_open_object_json() {
    const JSON: &str = "{";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_open_object_close_array_json() {
    const JSON: &str = "{]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::BracketClose);
}

#[test]
fn should_err_on_structure_open_object_comma_json() {
    const JSON: &str = "{,";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Comma);
}

#[test]
fn should_err_on_structure_open_object_open_array_json() {
    const JSON: &str = "{[";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_open_object_open_string_json() {
    const JSON: &str = r#"{"a"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_structure_open_object_string_with_apostrophes_json() {
    const JSON: &str = "{'a'";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_open_open_json() {
    const JSON: &str = r#"["\{["\{["\{["\{"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_structure_single_star_json() {
    const JSON: &str = "*";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_trailing_hash_json() {
    const JSON: &str = r#"{"a":"b"}#{}"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::CurlyOpen);
}

#[test]
fn should_err_on_structure_uescaped_lf_before_string_json() {
    const JSON: &str = r#"[\u000A""]"#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_structure_unclosed_array_json() {
    const JSON: &str = "[1";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_unclosed_array_partial_null_json() {
    const JSON: &str = "[ false, nul";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_unclosed_array_unfinished_false_json() {
    const JSON: &str = "[ true, fals";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_unclosed_array_unfinished_true_json() {
    const JSON: &str = "[ false, tru";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_unclosed_object_json() {
    const JSON: &str = r#"{"asd":"asd""#;

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_unicode_min_identifier_json() {
    const JSON: &str = "å";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_structure_utf8_bom_no_data_json() {
    const JSON: &str = "";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_parse_array_arrays_with_spaces_json() {
    const JSON: &str = "[[]   ]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let elems = assert_matches!(elem.into_value(), Value::Array(elems) => elems);
    assert!(elems.is_empty());
}

#[test]
fn should_parse_array_empty_min_string_json() {
    const JSON: &str = r#"[""]"#;

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::String(s) => s);
    assert_eq!(s.as_raw(), "");
}

#[test]
fn should_parse_array_empty_json() {
    const JSON: &str = "[]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    assert!(elems.is_empty());
}

#[test]
fn should_parse_array_ending_with_newline_json() {
    const JSON: &str = r#"["a"]"#;

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::String(s) => s);
    assert_eq!(s.as_raw(), "a");
}

#[test]
fn should_parse_array_false_json() {
    const JSON: &str = "[false]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    assert_matches!(elem.into_value(), Value::False);
}

#[test]
fn should_parse_array_heterogeneous_json() {
    const JSON: &str = r#"[null, 1, "1", {}]"#;

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem_a, elem_b, elem_c, elem_d] = elems.try_into().unwrap();
    assert_matches!(elem_a.into_value(), Value::Null);
    let s = assert_matches!(elem_b.into_value(), Value::Number(s) => s);
    assert_eq!(s, "1");
    let s = assert_matches!(elem_c.into_value(), Value::String(s) => s);
    assert_eq!(s.as_raw(), "1");
    let elems = assert_matches!(elem_d.into_value(), Value::Object(elems) => elems);
    assert!(elems.is_empty());
}

#[test]
fn should_parse_array_null_json() {
    const JSON: &str = "[null]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    assert_matches!(elem.into_value(), Value::Null);
}

#[test]
fn should_parse_array_with_1_and_newline_json() {
    const JSON: &str = "[1
]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "1");
}

#[test]
fn should_parse_array_with_leading_space_json() {
    const JSON: &str = " [1]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "1");
}

#[test]
fn should_parse_array_with_several_null_json() {
    const JSON: &str = "[1,null,null,null,2]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem_a, elem_b, elem_c, elem_d, elem_e] = elems.try_into().unwrap();
    let s = assert_matches!(elem_a.into_value(), Value::Number(s) => s);
    assert_eq!(s, "1");

    assert_matches!(elem_b.into_value(), Value::Null);
    assert_matches!(elem_c.into_value(), Value::Null);
    assert_matches!(elem_d.into_value(), Value::Null);

    let s = assert_matches!(elem_e.into_value(), Value::Number(s) => s);
    assert_eq!(s, "2");
}

#[test]
fn should_parse_array_with_trailing_space_json() {
    const JSON: &str = "[2] ";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "2");
}

#[test]
#[ignore = "Pending fix see https://git.service.d11n.nl/tandemdrive/ocpi-tariffs/issues/14"]
fn should_parse_structure_100000_opening_arrays() {
    const JSON: &str =
        include_str!("../../../test_data/json/n_structure_100000_opening_arrays.json");

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_parse_number_json() {
    const JSON: &str = "[123e65]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "123e65");
}

#[test]
fn should_parse_number_0e_plus_1_json() {
    const JSON: &str = "[0e+1]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "0e+1");
}

#[test]
fn should_parse_number_0e1_json() {
    const JSON: &str = "[0e1]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "0e1");
}

#[test]
fn should_parse_number_after_space_json() {
    const JSON: &str = "[ 4]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "4");
}

#[test]
fn should_parse_number_double_close_to_zero_json() {
    const JSON: &str =
        "[-0.000000000000000000000000000000000000000000000000000000000000000000000000000001]
";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(
        s,
        "-0.000000000000000000000000000000000000000000000000000000000000000000000000000001"
    );
}

#[test]
fn should_parse_number_int_with_exp_json() {
    const JSON: &str = "[20e1]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "20e1");
}

#[test]
fn should_parse_number_minus_zero_json() {
    const JSON: &str = "[-0]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "-0");
}

#[test]
fn should_parse_number_negative_int_json() {
    const JSON: &str = "[-123]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "-123");
}

#[test]
fn should_parse_number_negative_one_json() {
    const JSON: &str = "[-1]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "-1");
}

#[test]
fn should_parse_number_negative_zero_json() {
    const JSON: &str = "[-0]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "-0");
}

#[test]
fn should_parse_number_real_capital_e_json() {
    const JSON: &str = "[1E22]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "1E22");
}

#[test]
fn should_parse_number_real_capital_e_neg_exp_json() {
    const JSON: &str = "[1E-2]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "1E-2");
}

#[test]
fn should_parse_number_real_capital_e_pos_exp_json() {
    const JSON: &str = "[1E+2]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "1E+2");
}

#[test]
fn should_parse_number_real_exponent_json() {
    const JSON: &str = "[123e45]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "123e45");
}

#[test]
fn should_parse_number_real_fraction_exponent_json() {
    const JSON: &str = "[123.456e78]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "123.456e78");
}

#[test]
fn should_parse_number_real_neg_exp_json() {
    const JSON: &str = "[1e-2]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "1e-2");
}

#[test]
fn should_parse_number_real_pos_exponent_json() {
    const JSON: &str = "[1e+2]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "1e+2");
}

#[test]
fn should_parse_number_simple_int_json() {
    const JSON: &str = "[123]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "123");
}

#[test]
fn should_parse_number_simple_real_json() {
    const JSON: &str = "[123.456789]";

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Array(elems) => elems);
    let [elem] = elems.try_into().unwrap();
    let s = assert_matches!(elem.into_value(), Value::Number(s) => s);
    assert_eq!(s, "123.456789");
}

#[test]
fn should_parse_object_json() {
    const JSON: &str = r#"{"field_a":"one", "field_b":"two"}"#;

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let fields = assert_matches!(value, Value::Object(fields) => fields);
    let [field_a, field_b] = fields.try_into().unwrap();

    {
        let (_id, path, span, value) = field_a.into_parts();

        assert_eq!(*path, "$.field_a");
        assert_eq!(spanned_json(span, JSON), r#""one""#);
        let s = assert_matches!(value, Value::String(s) => s);
        assert_eq!(s.as_raw(), "one");
    }

    {
        let (_id, path, span, value) = field_b.into_parts();

        assert_eq!(*path, "$.field_b");
        assert_eq!(spanned_json(span, JSON), r#""two""#);
        let s = assert_matches!(value, Value::String(s) => s);
        assert_eq!(s.as_raw(), "two");
    }
}

#[test]
fn should_parse_object_basic_json() {
    const JSON: &str = r#"{"asd":"sdf"}"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_object_duplicated_key_json() {
    const JSON: &str = r#"{"a":"one","a":"two"}"#;

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let fields = assert_matches!(value, Value::Object(fields) => fields);
    let [field_a, field_b] = fields.try_into().unwrap();

    {
        let (_id, path, span, value) = field_a.into_parts();

        assert_eq!(*path, "$.a");
        assert_eq!(spanned_json(span, JSON), r#""one""#);
        let s = assert_matches!(value, Value::String(s) => s);
        assert_eq!(s.as_raw(), "one");
    }

    {
        let (_id, path, span, value) = field_b.into_parts();

        assert_eq!(*path, "$.a");
        assert_eq!(spanned_json(span, JSON), r#""two""#);
        let s = assert_matches!(value, Value::String(s) => s);
        assert_eq!(s.as_raw(), "two");
    }
}

#[test]
fn should_parse_object_duplicated_key_and_value_json() {
    const JSON: &str = r#"{"a":"one","a":"one"}"#;

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let fields = assert_matches!(value, Value::Object(fields) => fields);
    let [field_a, field_b] = fields.try_into().unwrap();

    {
        let (_id, path, span, value) = field_a.into_parts();

        assert_eq!(*path, "$.a");
        assert_eq!(spanned_json(span, JSON), r#""one""#);
        let s = assert_matches!(value, Value::String(s) => s);
        assert_eq!(s.as_raw(), "one");
    }

    {
        let (_id, path, span, value) = field_b.into_parts();

        assert_eq!(*path, "$.a");
        assert_eq!(spanned_json(span, JSON), r#""one""#);
        let s = assert_matches!(value, Value::String(s) => s);
        assert_eq!(s.as_raw(), "one");
    }
}

#[test]
fn should_parse_object_empty_json() {
    const JSON: &str = "{}";

    test::setup();

    let elem = parse(JSON.into()).unwrap();
    let (_id, path, span, value) = elem.into_parts();

    let elems = assert_matches!(value, Value::Object(elems) => elems);

    assert_eq!(spanned_json(span, JSON), JSON);
    assert_eq!(*path, "$");
    assert_eq!(elems, vec![]);
}

#[test]
fn should_parse_object_empty_key_json() {
    const JSON: &str = r#"{"":0}"#;

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Object(elems) => elems);
    let [elem_a] = elems.try_into().unwrap();

    {
        let (_id, path, span, value) = elem_a.into_parts();

        assert_eq!(*path, "$.");
        assert_eq!(spanned_json(span, JSON), "0");
        let s = assert_matches!(value, Value::Number(s) => s);
        assert_eq!(s, "0");
    }
}

#[test]
fn should_parse_object_escaped_null_in_key_json() {
    const JSON: &str = r#"{"foo\u0000bar": 42}"#;

    test::setup();

    let value = parse(JSON.into()).unwrap().into_value();
    let elems = assert_matches!(value, Value::Object(elems) => elems);
    let [elem_a] = elems.try_into().unwrap();

    {
        let (_id, path, span, value) = elem_a.into_parts();

        assert_eq!(*path, r"$.foo\u0000bar");
        assert_eq!(spanned_json(span, JSON), "42");
        let s = assert_matches!(value, Value::Number(s) => s);
        assert_eq!(s, "42");
    }
}

#[test]
fn should_parse_object_extreme_numbers_json() {
    const JSON: &str = r#"{ "min": -1.0e+28, "max": 1.0e+28 }"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_object_long_strings_json() {
    const JSON: &str = r#"{"x":[{"id": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"}], "id": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"}"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_object_simple_json() {
    const JSON: &str = r#"{"a":[]}"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_object_string_unicode_json() {
    const JSON: &str = r#"{"title":"\u041f\u043e\u043b\u0442\u043e\u0440\u0430 \u0417\u0435\u043c\u043b\u0435\u043a\u043e\u043f\u0430" }"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_object_with_newlines_json() {
    const JSON: &str = r#"{
"a": "b"
}"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_1_2_3_bytes_utf_min_8_sequences_json() {
    const JSON: &str = r#"["\u0060\u012a\u12AB"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_accepted_surrogate_pair_json() {
    const JSON: &str = r#"["\uD801\udc37"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_accepted_surrogate_pairs_json() {
    const JSON: &str = r#"["\ud83d\ude39\ud83d\udc8d"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_allowed_escapes_json() {
    const JSON: &str = r#"["\"\\\/\b\f\n\r\t"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_backslash_and_u_escaped_zero_json() {
    const JSON: &str = r#"["\\u0000"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_backslash_doublequotes_json() {
    const JSON: &str = r#"["\""]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_comments_json() {
    const JSON: &str = r#"["a/*b*/c/*d//e"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_double_escape_a_json() {
    const JSON: &str = r#"["\\a"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_double_escape_n_json() {
    const JSON: &str = r#"["\\n"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_escaped_control_character_json() {
    const JSON: &str = r#"["\u0012"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_escaped_noncharacter_json() {
    const JSON: &str = r#"["\uFFFF"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_in_array_json() {
    const JSON: &str = r#"["asd"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_in_array_with_leading_space_json() {
    const JSON: &str = r#"[ "asd"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_last_surrogates_1_and_2_json() {
    const JSON: &str = r#"["\uDBFF\uDFFF"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_nbsp_uescaped_json() {
    const JSON: &str = r#"["new\u00A0line"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_noncharacterinutf_min_8_u_plus_10ffff_json() {
    const JSON: &str = r#"["􏿿"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_noncharacterinutf_min_8_u_plus_ffff_json() {
    const JSON: &str = r#"["￿"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_null_escape_json() {
    const JSON: &str = r#"["\u0000"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_one_min_byte_min_utf_min_8_json() {
    const JSON: &str = r#"["\u002c"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_pi_json() {
    const JSON: &str = r#"["π"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_reservedcharacterinutf_min_8_u_plus_1bfff_json() {
    const JSON: &str = r#"["𛿿"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_simple_ascii_json() {
    const JSON: &str = r#"["asd "]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_space_json() {
    const JSON: &str = r#"" ""#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_surrogates_u_plus_1d11e_musical_symbol_g_clef_json() {
    const JSON: &str = r#"["\uD834\uDd1e"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_three_min_byte_min_utf_min_8_json() {
    const JSON: &str = r#"["\u0821"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_two_min_byte_min_utf_min_8_json() {
    const JSON: &str = r#"["\u0123"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_u_plus_2028_line_sep_json() {
    const JSON: &str = r#"["
"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_u_plus_2029_par_sep_json() {
    const JSON: &str = r#"["
"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_uescape_json() {
    const JSON: &str = r#"["\u0061\u30af\u30EA\u30b9"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_uescaped_newline_json() {
    const JSON: &str = r#"["new\u000Aline"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_unescaped_char_delete_json() {
    const JSON: &str = r#"[""]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_unicode_json() {
    const JSON: &str = r#"["\uA66D"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_unicode_2_json() {
    const JSON: &str = r#"["⍂㈴⍂"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_unicode_escaped_double_quote_json() {
    const JSON: &str = r#"["\u0022"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_unicode_u_plus_1fffe_nonchar_json() {
    const JSON: &str = r#"["\uD83F\uDFFE"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_unicode_u_plus_10fffe_nonchar_json() {
    const JSON: &str = r#"["\uDBFF\uDFFE"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_unicode_u_plus_200b_zero_width_space_json() {
    const JSON: &str = r#"["\u200B"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_unicode_u_plus_2064_invisible_plus_json() {
    const JSON: &str = r#"["\u2064"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_unicode_u_plus_fdd0_nonchar_json() {
    const JSON: &str = r#"["\uFDD0"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_unicode_u_plus_fffe_nonchar_json() {
    const JSON: &str = r#"["\uFFFE"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_unicodeescapedbackslash_json() {
    const JSON: &str = r#"["\u005C"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_utf8_json() {
    const JSON: &str = r#"["€𝄞"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_with_del_character_json() {
    const JSON: &str = r#"["aa"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_structure_lonely_false_json() {
    const JSON: &str = "false";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_structure_lonely_int_json() {
    const JSON: &str = "42";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_structure_lonely_negative_real_json() {
    const JSON: &str = "-0.1";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_structure_lonely_null_json() {
    const JSON: &str = "null";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_structure_lonely_string_json() {
    const JSON: &str = r#""asd""#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_structure_lonely_true_json() {
    const JSON: &str = "true";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_structure_string_empty_json() {
    const JSON: &str = r#""""#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_structure_trailing_newline_json() {
    const JSON: &str = r#"["a"]
"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_structure_true_in_array_json() {
    const JSON: &str = "[true]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_structure_whitespace_array_json() {
    const JSON: &str = " [] ";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_array_just_minus_json() {
    const JSON: &str = "[-]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_multidigit_number_then_00_json() {
    const JSON: &str = "123";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_0_1_2_json() {
    const JSON: &str = "[0.1.2]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_0_3e_json() {
    const JSON: &str = "[0.3e]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_plus_plus_json() {
    const JSON: &str = "[++1234]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_plus_1_json() {
    const JSON: &str = "[+1]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_min_01_json() {
    const JSON: &str = "[-01]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_min_1_0_dot_json() {
    const JSON: &str = "[-1.0.]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_min_2_dot_json() {
    const JSON: &str = "[-2.]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_min_nan_json() {
    const JSON: &str = "[-NaN]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_dot_min_1_json() {
    const JSON: &str = "[.-1]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_1ee2_json() {
    const JSON: &str = "[1eE2]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_9_dot_e_plus_json() {
    const JSON: &str = "[9.e+]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_0_3eplus_json() {
    const JSON: &str = "[0.3e+]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_0_dot_e1_json() {
    const JSON: &str = "[0.e1]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_0_capital_e_json() {
    const JSON: &str = "[0E]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_0_capital_eplus_json() {
    const JSON: &str = "[0E+]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_0e_json() {
    const JSON: &str = "[0e]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_0eplus_json() {
    const JSON: &str = "[0e+]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_1_0e_json() {
    const JSON: &str = "[1.0e]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_1_0emin_json() {
    const JSON: &str = "[1.0e-]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_1_0eplus_json() {
    const JSON: &str = "[1.0e+]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_expression_json() {
    const JSON: &str = "[1+2]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_invalid_plus_min_json() {
    const JSON: &str = "[0e+-1]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_nan_json() {
    const JSON: &str = "[NaN]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_neg_int_starting_with_zero_json() {
    const JSON: &str = "[-012]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_neg_real_without_int_part_json() {
    const JSON: &str = "[-.123]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_neg_with_garbage_at_end_json() {
    const JSON: &str = "[-1x]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_real_garbage_after_e_json() {
    const JSON: &str = "[1ea]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_real_without_fractional_part_json() {
    const JSON: &str = "[1.]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_starting_with_dot_json() {
    const JSON: &str = "[.123]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_u_plus_ff11_fullwidth_digit_one_json() {
    const JSON: &str = "[１]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_number_with_leading_zero_json() {
    const JSON: &str = "[012]";

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_err_on_number_inf_json() {
    const JSON: &str = "[Inf]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_number_hex_1_digit_json() {
    const JSON: &str = "[0x1]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Number);
}

#[test]
fn should_err_on_number_hex_2_digits_json() {
    const JSON: &str = "[0x42]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Number);
}

#[test]
fn should_err_on_number_infinity_json() {
    const JSON: &str = "[Infinity]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_number_minus_infinity_json() {
    const JSON: &str = "[-Infinity]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Invalid);
}

#[test]
fn should_err_on_number_minus_sign_with_trailing_garbage_json() {
    const JSON: &str = "[-foo]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_err_on_number_minus_space_1_json() {
    const JSON: &str = "[- 1]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Number);
}

#[test]
fn should_err_on_number_with_alpha_json() {
    const JSON: &str = "[1.2a-3]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Number);
}

#[test]
fn should_err_on_number_with_alpha_char_json() {
    const JSON: &str = "[1.8011670033376514H-308]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedToken);
    assert_eq!(err.token().unwrap().kind, TokenType::Number);
}

#[test]
fn should_err_on_number_invalid_negative_real_json() {
    const JSON: &str = "[-123.123foo]";

    test::setup();

    let err = parse(JSON.into()).unwrap_err();
    assert_matches!(err.kind(), ErrorKind::UnexpectedEOF);
}

#[test]
fn should_parse_object_trailing_comment_json() {
    const JSON: &str = r#"{"a":"b"}/**/"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_object_trailing_comment_open_json() {
    const JSON: &str = r#"{"a":"b"}/**//"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_object_trailing_comment_slash_open_json() {
    const JSON: &str = r#"{"a":"b"}//"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_object_trailing_comment_slash_open_incomplete_json() {
    const JSON: &str = r#"{"a":"b"}/"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_unescaped_ctrl_char_json() {
    const JSON: &str = r#"["aa"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_unescaped_newline_json() {
    const JSON: &str = r#"["new
line"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
fn should_parse_string_unescaped_tab_json() {
    const JSON: &str = r#"["	"]"#;

    test::setup();

    let _elem = parse(JSON.into()).unwrap();
}

#[test]
#[ignore = "The `json-tools` parser should fail on emojis"]
fn should_err_on_object_emoji_json() {
    const JSON: &str = "{🇨🇭}";

    test::setup();

    let _err = parse(JSON.into()).unwrap_err();
}

#[test]
#[ignore = "The `json-tools` parser should fail on trailing garbage"]
fn should_err_on_string_with_trailing_garbage_json() {
    const JSON: &str = r#"""x"#;

    test::setup();

    let _err = parse(JSON.into()).unwrap_err();
}

#[test]
fn should_err_on_structure_u_plus_2060_word_joined_json() {
    const JSON: &str = r"[\u{2060}]";

    test::setup();

    let _err = parse(JSON.into()).unwrap_err();
}

#[test]
#[ignore = "The `json-tools` parser should fail on a dot in an angle bracket"]
fn should_err_on_structure_dot_in_angle_bracket_json() {
    const JSON: &str = "<.>";

    test::setup();

    let _err = parse(JSON.into()).unwrap_err();
}

#[test]
#[ignore = "The `json-tools` parser should fail on a null in an angle bracket"]
fn should_err_on_structure_angle_bracket_null_json() {
    const JSON: &str = "[<null>]";

    test::setup();

    let _err = parse(JSON.into()).unwrap_err();
}

#[test]
#[ignore = "The `json-tools` parser should fail on capitalized true"]
fn should_err_on_structure_capitalized_true_json() {
    const JSON: &str = "[True]";

    test::setup();

    let _err = parse(JSON.into()).unwrap_err();
}

#[test]
#[ignore = "The `json-tools` parser should fail on trailing garbage"]
fn should_err_on_structure_array_trailing_garbage_json() {
    const JSON: &str = "[1]x";

    test::setup();

    let _err = parse(JSON.into()).unwrap_err();
}

#[test]
#[ignore = "The `json-tools` parser should fail on whitespace formfeed"]
fn should_err_on_structure_whitespace_formfeed_json() {
    const JSON: &str = "[]";

    test::setup();

    let _err = parse(JSON.into()).unwrap_err();
}

#[test]
fn should_err_on_structure_whitespace_u_plus_2060_word_joiner_json() {
    const JSON: &str = r"[\u{2060}]";

    test::setup();

    let _err = parse(JSON.into()).unwrap_err();
}

#[test]
#[ignore = "The `json-tools` parser should fail on null min byte"]
fn should_err_on_structure_null_min_byte_min_outside_min_string_json() {
    const JSON: &str = "[]";

    test::setup();

    let _err = parse(JSON.into()).unwrap_err();
}

#[test]
#[ignore = "The `json-tools` parser should fail on trailing garbage"]
fn should_err_on_structure_number_with_trailing_garbage_json() {
    const JSON: &str = "2@";

    test::setup();

    let _err = parse(JSON.into()).unwrap_err();
}

#[test]
#[ignore = "The `json-tools` parser should fail on star inside json"]
fn should_err_on_array_star_inside_json() {
    const JSON: &str = "[*]";

    test::setup();

    let _err = parse(JSON.into()).unwrap_err();
}

#[test]
#[ignore = "The `json-tools` parser should fail on trailing garbage"]
fn should_err_on_object_with_trailing_garbage_json() {
    const JSON: &str = r#"{"a":"b"}#"#;

    test::setup();

    let _err = parse(JSON.into()).unwrap_err();
}

#[test]
#[ignore = "The `json-tools` parser should fail on accented char"]
fn should_err_on_string_accented_char_no_quotes_json() {
    const JSON: &str = "[é]";

    test::setup();

    let _err = parse(JSON.into()).unwrap_err();
}