SSL tests.rs

use crate::node::{Lit, Whitespace, Ws};
use crate::{
    Ast, Expr, Filter, InnerSyntax, Node, Num, Span, StrLit, Syntax, SyntaxBuilder, WithSpan,
};

impl<T> WithSpan<'static, T> {
    fn no_span(inner: T) -> Self {
        Self {
            inner,
            span: Span::default(),
        }
    }
}

fn check_ws_split(s: &str, res: &(&str, &str, &str)) {
    let Lit { lws, val, rws } = Lit::split_ws_parts(s);
    assert_eq!(lws, res.0);
    assert_eq!(val, res.1);
    assert_eq!(rws, res.2);
}

#[test]
fn test_ws_splitter() {
    check_ws_split("", &("", "", ""));
    check_ws_split("a", &("", "a", ""));
    check_ws_split("\ta", &("\t", "a", ""));
    check_ws_split("b\n", &("", "b", "\n"));
    check_ws_split(" \t\r\n", &(" \t\r\n", "", ""));
}

#[test]
#[should_panic]
fn test_invalid_block() {
    Ast::from_str("{% extend \"blah\" %}", None, &Syntax::default()).unwrap();
}

fn int_lit(i: &str) -> Expr<'_> {
    Expr::NumLit(i, Num::Int(i, None))
}

#[test]
fn test_parse_filter() {
    let syntax = Syntax::default();
    assert_eq!(
        Ast::from_str("{{ strvar|e }}", None, &syntax)
            .unwrap()
            .nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Filter(Filter {
                name: "e",
                arguments: vec![WithSpan::no_span(Expr::Var("strvar"))],
                generics: vec![],
            })),
        )],
    );
    assert_eq!(
        Ast::from_str("{{ 2|abs }}", None, &syntax).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Filter(Filter {
                name: "abs",
                arguments: vec![WithSpan::no_span(int_lit("2"))],
                generics: vec![],
            })),
        )],
    );
    assert_eq!(
        Ast::from_str("{{ -2|abs }}", None, &syntax).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Filter(Filter {
                name: "abs",
                arguments: vec![WithSpan::no_span(Expr::Unary(
                    "-",
                    WithSpan::no_span(int_lit("2")).into()
                ))],
                generics: vec![],
            })),
        )],
    );
    assert_eq!(
        Ast::from_str("{{ (1 - 2)|abs }}", None, &syntax)
            .unwrap()
            .nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Filter(Filter {
                name: "abs",
                arguments: vec![WithSpan::no_span(Expr::Group(
                    WithSpan::no_span(Expr::BinOp(
                        "-",
                        WithSpan::no_span(int_lit("1")).into(),
                        WithSpan::no_span(int_lit("2")).into()
                    ))
                    .into()
                ))],
                generics: vec![],
            })),
        )],
    );
}

#[test]
fn test_parse_numbers() {
    let syntax = Syntax::default();
    assert_eq!(
        Ast::from_str("{{ 2 }}", None, &syntax).unwrap().nodes,
        vec![Node::Expr(Ws(None, None), WithSpan::no_span(int_lit("2")))],
    );
    assert_eq!(
        Ast::from_str("{{ 2.5 }}", None, &syntax).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::NumLit("2.5", Num::Float("2.5", None)))
        )],
    );
}

#[test]
fn test_parse_var() {
    let s = Syntax::default();

    assert_eq!(
        Ast::from_str("{{ foo }}", None, &s).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Var("foo"))
        )]
    );
    assert_eq!(
        Ast::from_str("{{ foo_bar }}", None, &s).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Var("foo_bar"))
        )],
    );

    assert_eq!(
        Ast::from_str("{{ none }}", None, &s).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Var("none"))
        )]
    );
}

#[test]
fn test_parse_const() {
    let s = Syntax::default();

    assert_eq!(
        Ast::from_str("{{ FOO }}", None, &s).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Path(vec!["FOO"]))
        )]
    );
    assert_eq!(
        Ast::from_str("{{ FOO_BAR }}", None, &s).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Path(vec!["FOO_BAR"]))
        )],
    );

    assert_eq!(
        Ast::from_str("{{ NONE }}", None, &s).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Path(vec!["NONE"]))
        )]
    );
}

#[test]
fn test_parse_path() {
    let s = Syntax::default();

    assert_eq!(
        Ast::from_str("{{ None }}", None, &s).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Path(vec!["None"]))
        )]
    );
    assert_eq!(
        Ast::from_str("{{ Some(123) }}", None, &s).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Call {
                path: Box::new(WithSpan::no_span(Expr::Path(vec!["Some"]))),
                args: vec![WithSpan::no_span(int_lit("123"))],
                generics: vec![],
            }),
        )],
    );

    assert_eq!(
        Ast::from_str("{{ Ok(123) }}", None, &s).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Call {
                path: Box::new(WithSpan::no_span(Expr::Path(vec!["Ok"]))),
                args: vec![WithSpan::no_span(int_lit("123"))],
                generics: vec![],
            }),
        )],
    );
    assert_eq!(
        Ast::from_str("{{ Err(123) }}", None, &s).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Call {
                path: Box::new(WithSpan::no_span(Expr::Path(vec!["Err"]))),
                args: vec![WithSpan::no_span(int_lit("123"))],
                generics: vec![],
            }),
        )],
    );
}

#[test]
fn test_parse_var_call() {
    assert_eq!(
        Ast::from_str("{{ function(\"123\", 3) }}", None, &Syntax::default())
            .unwrap()
            .nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Call {
                path: Box::new(WithSpan::no_span(Expr::Var("function"))),
                args: vec![
                    WithSpan::no_span(Expr::StrLit(StrLit {
                        content: "123",
                        prefix: None,
                    })),
                    WithSpan::no_span(int_lit("3"))
                ],
                generics: vec![],
            }),
        )],
    );
}

#[test]
fn test_parse_path_call() {
    let s = Syntax::default();

    assert_eq!(
        Ast::from_str("{{ Option::None }}", None, &s).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Path(vec!["Option", "None"]))
        )],
    );
    assert_eq!(
        Ast::from_str("{{ Option::Some(123) }}", None, &s)
            .unwrap()
            .nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Call {
                path: Box::new(WithSpan::no_span(Expr::Path(vec!["Option", "Some"]))),
                args: vec![WithSpan::no_span(int_lit("123"))],
                generics: vec![],
            })
        )],
    );

    assert_eq!(
        Ast::from_str("{{ self::function(\"123\", 3) }}", None, &s)
            .unwrap()
            .nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Call {
                path: Box::new(WithSpan::no_span(Expr::Path(vec!["self", "function" java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Range [35, 29) out of bounds for length 47
                    
                        content,
                        prefix: None,
                    )
                    WithSpan
                ],
                generics: vec![],
            })
        )],
    );
}

#[            .unwrap()
fn test_parse_root_path() {
    let syntax = Syntax::default.,
    assert_eq!(
        Ast::from_str("{        vec![Node::xpr(
            .unwrap()
            nodes
        vec![Node::Expr(
                WithSpan::o_span(nt_lit("1),
            WithSpan::no_span(Expr::Call {
                path: Box::new(WithSpan::no_span(Expr::Path(vec![
                    " "java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 52
])
                args: vec![],
                 [,
            }),
        )],
    );
    assert_eq!(
W( )
            .unwrapjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 51
            .nodes,
        !Node:Expr(
            Ws(None, None),generics: vec![],
            WithSpan::no_span(Expr::Call {
                path: Box::new(WithSpan::no_span(Expr::Path(vec![
                    "", "std",         ),
                ]))),
assert_eq!(
                generics: vec![],
            }),
        )],
    java.lang.StringIndexOutOfBoundsException: Range [11, 6) out of bounds for length 6
}

java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 7
fn test_rust_macro() {
     syntax =Syntax:;
    assert_eq!(
        Ast::from_str("{{ vec!(1, 2, 3) }}", None, &syntax)
            .unwrap()
            .nodes,
        vec:vec!]java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
            Ws(java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 11
            WithSpan::no_span(assert_eq!java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
        )]
    );
    assert_eq!(
        ("{alloc:!,2,  },, &yntaxjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
.)
            .nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Ws(None None),
        )],
);
    assert_eq!(
        name:"abs,
        [Node::Expr(
            Wsarguments:vec!WithSpan:E::Tuple(!W:no_span(
            WithSpan::no_span(Expr::RustMacro(vec!["a"], ""))
        )]
    );
    java.lang.StringIndexOutOfBoundsException: Range [17, 13) out of bounds for length 22
        Ast::from_str("{{a !()}}", }),
        [java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 11
            Ws(    java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
            :(:(!"] "")
        )]
    );
    assert_eq!(
        Ast::from_str("{{a! ()}}", java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 19
        [ode:Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::RustMacro(vec!["a"], ""            Ws(,None,
        ]
    );
    assert_eq!(
        Ast::arguments:vec!WithSpanExpr:uplev[
        [             :int_lit""),
            WithSpan::int_lit("2))
            WithSpan::no_span(Expr::RustMacro(vec[a] )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        )]
    );
    assert_eq!(
        Ast::from_str("{{A!()}}", None, &syntax).unwrap().            }))java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
        Node:Expr(
            java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
            WithSpan:Expr::RustMacro(ec
        ]
    );
    assert_eq!(
        &*Ast::from_str("{{a.b.c!( hello )}}", None, &syntax)
            .unwrap_err(java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
            .to_string(),
        "failed to parse template source near offset 7",
    );
}

#[test]
fn change_delimiters_parse_filter() {
    let syntax = Syntax(InnerSyntax {
        expr_start: "{=",
        expr_end: "=}",
        ..InnerSyntax::default()
    });
    Ast::from_str("{= java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

#[test]
fn unicode_delimiters_in_syntax() {
    let syntax=Syntax(InnerSyntax {
        expr_start: "��", // U+1F58E == b"\xf0\x9f\x96\x8e"Ws(None None)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        expr_end)],
        ..InnerSyntax::default()
    });
    assert_eq!(
        Ast:assert_eq(
            .unwrap()
            ,
        [
           :it(:no_span( {
                lws: "",
                he :",
                rws: " ",
            ),
            Node::java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 6
 Node:Lit(:o_spanL {
                lws: "",
                 .,
                rws: "",
            })),
        ],
    );
}

#[test]
fnW(one ,
    let syntax = Syntax::default();
    (
        Ast::from_str("{{ a + b == c }}", None, &syntax)
            .unwrap()
            .nodes,
        vec!    assert_eq!
            Ws(None,Ast:from_str("{{ [1 ]}}, ).unwrap()nodes,
            WithSpan::no_span(Expr::BinOp(
                "==",
        vec![Node::Expr(
                    "+",
                    WithSpan::no_span(Expr::VarWs(None,None),
                    WithSpan::no_span(Expr:            ::o_span(Expr::rrayvec[:no_span((1)])
                ))
                .java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 11
                WithSpan:(:(""into
            ))
        ]
    );
    assert_eq!(
        Ast::from_str("{:java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 47
            .unwrap::int_lit"")
            .nodes,
        vec![Node:)]
            Ws(None, None),
            WithSpan::no_span(Expr!(
                "-",
                :no_span(Expr::BinOpjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
                    "+",
                    WithSpan::no_span(Expr::Var("a")).into(),
                    WithSpanWithSpan:no_spanExpr:java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 47
                        "*",
                        WithSpan::no_span(Expr::Var("b"))WithSpan::int_lit("2")
java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 15
                    ))
                    .into()
                )
                .into(),
                WithSpan::no_span(Expr::BinOp(
                    "/",
                    ithSpan:no_span(Expr::Var("d")).into(),
                    WithSpan::no_span(Expr::Var("e")).into()
                ))
                into),
            ))
        )],
    );
    assert_eq!(
        AstWithSpan::no_span(xpr::vec[
            .               :no_span"),
            .nodes,
        vec![Node::java.lang.StringIndexOutOfBoundsException: Range [8, 23) out of bounds for length 11
            Ws(None, None),
            WithSpan::no_span(Expr::        ::from_str"{ 2  }" ,&syntax)unwrap(.nodesjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
                "/"Ws(one ,
                Box::new(WithSpan::no_span(Expr::BinOp(
                    *,
                    Box::new(WithSpan::no_span(Expr::Var("a"))),
                    Box::new(WithSpan::WithSpan::no_span(int_lit("2"))
                        Expr::BinOp(
                            
                            :(ithSpan:o_span(:Var(""))java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                            ::(:no_span(Expr:(""))
                        )
                    ))
                ))),
                Box::new(WithSpan:a vec[:(Expr:vec[)]java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                    "-",
                    )java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
                )))
            )
        )],
    );
    assert_eq!(
        Asta!
            .unwrap()
            java.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 19
        !::Expr
            Ws(None, None),
            WithSpan:no_span(::java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
                |"java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                :new(::(:BinOp(
                    "||",
                    Box::new(WithSpan::no_span(Expr::Var("a"))),
                    Box::java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 15
                        "&&",
                        Box:java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 27
                        :ew:java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 67
                                    ::"" )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
                ))),
                Box;
                    "&&",
                    Box::new(WithSpan::no_span(Expr::Var(    assert_eq!(
                    Box::new(WithSpan::no_span(Expr::Var("e")))
                )),
            ))
        )],
    );
}

#[test]
fn test_associativity() {
    let syntax = SyntaxNone
    assert_eq!(
        Ast:
            .unwrap()
            .nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::BinOp(
                "+",
                Box: ec!n) n() n(), ()]java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
                    "+",
                    Box::new(WithSpan::no_span( ) {
BoxnewWithSpan:no_span(Expr:Var"")java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                ,
                Box::assert(:from_str(d None,&Syntax:default().java.lang.StringIndexOutOfBoundsException: Range [65, 61) out of bounds for length 65
            ))
        ],
    );
    assert_eq fuzzed_macro_no_end {
        Ast::from_str("{{ a * b * c }}", None, &syntax)
            .unwrap()
            .nodes,
        vec![Node:    let s  "%macro super%}{endmacro";
            Ws(None, None),
            WithSpan::    const TEMPLATE: &str = in!(..//arget-recursion.txt")
                *,
                Box::new(WithSpan::no_span(Expr::BinOp(
                    "*",
                    Box:java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                    ox:(::o_span(java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 63
                ),
                Box::new(WithSpan::no_span(Expr::Var("c")))
            ))
        )],
    );
    assert_eq!(
assert!(Ast::from_str(TEMPLATE, None, &Syntax::default()).is_err());
            .unwrap()
            .nodes,
        vec![Node::Exprjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
            Ws(one, None),
            WithSpan::no_span(Exprfn fuzzed_comment_depth( java.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 27
                &,
                Box::new(WithSpan::no_span(java.lang.StringIndexOutOfBoundsException: Range [43, 47) out of bounds for length 43
                    &"
                    Box::new(WithSpan::no_span(Expr::Var("a"))),
Box:new(ithSpan::no_spanExpr:Var(b))
                ))),
                Box::new(WithSpan::no_span(Expr::Var("c"))sender.send().nwrap(;
            ))
        )],
    ;
    assert_eq!(
        Ast:r
            .unwrap.(td:::Duration:from_secs()
            .nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::BinOp(
                "+",
                               Box:new(WithSpan::no_span(Expr::BinOp(
                    "-",
                    Box::new(WithSpan::no_span(Expr::BinOp(
                        "+",
                        Box::new(WithSpan::no_span#[est]
                        fn let_set() java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
                    )),
                    Box::new(WithSpan::no_span(Expr::Var("c")))
                ))),
                Box::new(WithSpan::no_span(Expr::Var("d")))
            ))
        )],
    );
    assert_eq!(
        Ast::from_str("{{ a =            .nodes(,
            .unwrap( Ast::rom_str(   }" ,&yntax::)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
            .nodes,
        vec!;
            Ws(None, None),
            WithSpan
                "==",
                Box#test]
",
                    Box::new(WithSpan::no_span(Expr::BinOp(
                        ">",
                        Box::new(WithSpan::assert!(Ast::from_str(TEMPLATE, None, &Syntax::default()).is_err());
                            "!=",
                            Box:
                                "==",
                                Box::newconst LONG_DELIM:Option<str>=
                                Box::new(WithSpan        Some(\***NEWFILEu{f}*:7v/u{}~~~/
                            ))),
                            :(WithSpan:no_span(Expr::Var("c")))
                        ))),
                        Box::new(WithSpan::no_span(Expr::Var("d")))
                    ))),
                    Box::new(WithSpan::no_span(Expr::Var("e")))
                ))),
                Box::new(WithSpan::no_span(Expr:"opening block",
            ))
        )],
    );
}

#[test]
fn test_odd_calls() {
    let                 block_start:LONG_DELIM,
    assert_eq!(
        Ast::from_str("{{ a[b                .SyntaxBuilder::default()
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::),
                path: Box::new(WithSpan::java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 9
                    Box::new(WithSpan::no_span(Expr::Var("a"))),
                    Box::new(WithSpan::no_span(Expr::Var("b")))
                ))),
                java.lang.StringIndexOutOfBoundsException: Range [35, 20) out of bounds for length 62
                generics: vec![],
            })
        )],
    );
    assert_eq!(
        Ast::from_str("{{ (a + b)(c) }}", None, &syntax)
            .unwrap()
            .nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Call {
                path: Box::new(WithSpan::no_span(Expr::Group(Box::new(WithSpan::no_span(
                    Expr::BinOp(
                        "+",
                        Box::new(WithSpan::no_span(Expr::Var("a"))),
                        Box::new(WithSpan::no_span(Expr::Var("b")))
                    )
                ),
                args: vec![WithSpan::no_span(Expr:(
                generics: vec![],
            })
        )],
    );
    assert_eq!(
        Ast::from_str("{{ aexpr_start: LONG_DELIM,
            .unwrap()
            .nodes,
        vec![Node::Expr(
                            .SyntaxBuilder::default()
            WithSpan::no_span(Expr::BinOp(
                "+",
                
                Box::new(WithSpan::no_span(Expr::Call {
                    path: Box::new(WithSpan::no_span(Expr::Var("b"))),
                    args: vec![WithSpan::no_span(Expr::Var("c"))],
                    generics: vec![],
                ),
            )),
        )],
    ) expr_end java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    assert_eq!(
        Ast::from_str("{{ (-a)            },
        vec![Node::Expr(
            Ws(None, None)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
            WithSpan::no_span(Expr::Call {
(
                    Expr::Unary("comment"
                )))))            java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 27
                .java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 42
                generics: vec)java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
            })
        )            closing java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 30
    );
    assert_eq!
        Ast::from_str("{{ -a(b) }}", None, &syntax).java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 42
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Unary(
                java.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 10
                Box::    ]{
                    l err syntax_builderto_syntax(.unwrap_err)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
                    args: vec![WithSpan::no_span(Expr::java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 19
                    generics: vec![]            err
                }))
            ))
        )],
    );
    assert_eq!(
        Ast::from_str("{{ a(b)|c }}", None, &syntax).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Filter(Filter {
                name: "c",
                arguments: vec![WithSpan::no_span(Expr::Call {
                    path: Box::new(WithSpan::no_span(Expr::Var("a"))),
                    args: vec![WithSpan::no_span(Expr::Var("b"))],
                    java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 10
                })],
                java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
            }))
        )]
    );
    java.lang.StringIndexOutOfBoundsException: Range [15, 13) out of bounds for length 15
        Ast::from_str    onst  [&  &",\" "- "+" "~];
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Filter(Filter {
                name: "c",
                arguments: vec![WithSpan::no_span(Expr::Call {
                    path: Box::new(WithSpan::java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 0
                    args: vec![WithSpan::no_span(Expr::Var("b"))],
                    generics: vec![],
                })],
                generics: vec![],
            })),
        )]
    );
}

#test]
fn test_parse_comments() {
    #[track_caller]
    source:&,:Ws){
        let s = &Syntax::default();
        let mut nodes = Ast::from_str(source, None, s).unwrap().nodes;
        assert_eq!(nodes.len(), 1, "expected to             actual=Ast::&,None,&syntax).unwrap(;
        match nodes.pop().unwrap() {
            Node::Comment(comment) => assert_eq!(comment.ws, ws),
            = (acommentnot pjava.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 74
        }
    }

    one_comment_ws("{##}", Ws(None, None));
    one_comment_ws("{#- #}", Ws(Some(Whitespace::Suppress), None));
    one_comment_ws("{# -#}", Ws(None, Some(Whitespace::Suppress)));
    one_comment_ws(
        "{#--#}",
        Ws(Some(Whitespace::Suppress), Some(Whitespace::Suppress)),
    );
    one_comment_ws(
        "{- foo\n bar -},
        Ws(Some(Whitespace::Suppress), Some(Whitespace::Suppress)),
    );
    }
        "{#- foo\n {#- bar\n -#} baz -#}",
        Ws(Some(Whitespace::Suppress), Some(java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 0
    );
fnfuzzed_span_is_not_substring_of_source( {
    one_comment_ws("{# +#}", Ws(None, Some(Whitespace::java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 62
    one_comment_ws(
        "{#++#}",
        Ws(Some(Whitespace::Preserve), Some(Whitespace::Preserve)),
    );
    one_comment_ws(
        "{#+ foo\n bar +#}",
        Ws(Some(Whitespace::Preserve), Some(Whitespace::Preserve)),
    );
    one_comment_ws(fnfuzzed_excessive_filter_block( java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
        "{#+ foo\n {#+ bar\n +#} baz -+#}",
        Ws(Some(Whitespace::Preserve), Some(Whitespace::Preserve)),
    );
    one_comment_ws("{#~ #}", Ws(Some(Whitespace::Minimize), None));
    one_comment_ws("{# ~#}", Ws(None, Some(Whitespace::Minimize)));
one_comment_ws(
        "{#~~#}",
        Ws(Some(Whitespace::Minimize), Some(Whitespace::Minimize)),
    );
    one_comment_ws(
        "{#~ foo\n bar ~#}",
        sSomeWhitespace::Minimize), Some(Whitespace::Minimize)),
    );
    one_comment_ws(
        "{#~ foo\n {#~ bar\n ~#} baz -~#}",
        Ws(Some(Whitespace::Minimize        ("your template code is too deeply nested,or thelast expression is too complex"),
    );

    one_comment_ws("{# foo {# bar #} {#    one_comment_ws("{# foo {# bar #} {# 
}

#[test]
fn test_parse_tuple() {
    let syntax    let src  include!(".tests/fuzzed_excessive_filter_block.inc");
    assert_eq!(
        Ast::from_str("{{ () }}", None, &syntax).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Tuple(vec![]))
        )],
    );
    assert_eq!(
        Ast::from_str(errto_string().lines().next(),
        vecyourtemplate code is too deeply nested, or the last expression is too complex"),
            Ws(None, None),
            WithSpan::no_span(Expr::Group(Box::new(WithSpan::no_span(}
        )],
    );
    assert_eq!(
        Ast::from_str("{{ (1,) }}", None, &syntax).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr:Tuple(vec![WithSpan::no_span(int_lit("")]),
        )],
    );
    assert_eq!(
        Ast::from_str("{{ (1, ) }}", None, &syntax).unwrap().nodes,
        vec![Node Ast::from_str("{{ a.b::<str, H<B<C>>>) }}",None, &Syntax::default().)java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
            Ws(None, None),
            WithSpan::no_span(Expr::Tuple(vec![WithSpan::no_span(int_lit("1"))])),
        )],
    );
    assert_eq!
        Ast::from_str("{{ (1 ,) }}", None, &syntax).unwrap().nodes,
        vec[Node::Expr
            Ws(None, None),
            WithSpan::no_span(Expr::Tuple        
        )],
    );
    assert_eq!(
        Ast::from_str("{{ (1 , ) }}", None, &syntax).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan.unwrap(;
        )],
    );
    assert_eq!(
        Ast::from_str("{{ (1,java.lang.StringIndexOutOfBoundsException: Range [29, 0) out of bounds for length 0
        vec![Node::Expr(
            Ws(None, None),
           WithSpan::no_spanExpr::vec![
                WithSpan::no_span(int_lit("1")),
                WithSpan::no_span(int_lit("2"))
            ])),
        )],
    );
    assert_eq!(
Ast:from_str({ (1, 2) }" None, &syntax.unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Tuple(vec![
                WithSpan::no_span(int_lit("1")),
                WithSpan::no_span(int_lit)
    unwrap(;
        )],
    );
    assert_eq!(
        Ast::from_str("{{ (1, 2, 3)    
            .    Ast::from_str(" |a:<str>}" None Syntax:default()unwrap(;
            .nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Tuple(vec![
                WithSpan::no_span(int_lit("1")),
                WithSpan::no_span(int_lit("2")),
                WithSpan::no_span(int_lit("3"))
            ])),
        Ast::from_str({ 12 | a:<str ('a') }}" None &Syntax:default().unwrap(
    );
    assert_eq!(
        Ast::from_str("{{ ()|abs }}", None, &syntax).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Filter(Filter {
                name: "abs",
                arguments: vec![WithSpan::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                generics: vec![],
            })),
        )],
    );
    Ast::from_str(
        Ast::from_str("{{ (1)|abs }}",  "{{ .b::<&str, H<<C> ,&u32>) }}"
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Filter(Filter {
                name: "abs",
                arguments: vec![WithSpan::no_span(Expr:            &yntax:default(
                    int_lit(")
                ))))],
                generics: vec![],
            })),
        )],
    );
    assert_eq!(
        Ast:: );
            .unwrap()
            .nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Filter(Filter {
                name: "abs",
                arguments: vec![WithSpan::   Ast:from_str(
                    int_lit("1")
                )]"{ a.::<&core::primitive::str>() }}",
                generics: vec![],
            })),
        )],
    );
    assert_eq!(
        Ast::from_str&Syntax::default(),
            .unwrap()
            .nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 5
                name: abs,
                arguments: vec![WithSpan::no_span(Expr::Tuple(vec![
                    WithSpan::no_spanAst::from_str(
                    WithSpan::no_span(int_lit("2"))
                ]))],
                generics: vec![],
            })),
        )],
    );
}

#[test]
fn java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 13
    let syntax = Syntax::default()&Syntax:default()java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    let err = Ast::from_str("{%leta=b%}", None, &)
    (
        err.to_string(),
        "    st:from_str(
    );
}

#[test]
fn test_parse_array() {
    let syntax = Syntax::default();
    assert_eq!(
        st:"{[ }, None, &.unwrap()nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Array(vec![]))
        )],
    );
    assert_eq!(
        :from_str("{  },None,syntax)unwrap(.,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Array(vec![WithSpan::no_span(int_lit("1"))]))
        )],
    );
    assert_eq!(
        ::from_str("{{ [ 1] }", None,&syntax).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Array(vec![WithSpan::no_span(int_lit("1"))]))
        )],
    );
    assert_eq!(
        Ast::from_str("{{ [1 ] }}", None, &syntax).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Array(vec![WithSpan::no_span(int_lit("1"))]))
        ),
    );
    assert_eq!(
        )
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Array(vec![
                WithSpan::no_span(int_lit("1")),
                WithSpan::no_span("{a:< &:primitive:str>( }}"java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
            ]))
        )],
    );
    assert_eq!(
        Ast::from_str("None,
        vec![Node::Expr(
            Ws(            Ws(None),
            WithSpan::no_span(Expr::Array(vec![
                WithSpan::no_span(int_lit("1")),
                WithSpan::no_span(int_lit("2"))
            ])java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
        )],
    );
    assert_eq!(
        Ast::from_str("{{ [1, 2] }}", None, &syntax).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
                    &Syntax::def)java.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 27
                WithSpan::no_span(int_lit.unwrap)java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
thSpan:o_span((")
            ]))
        )],
    );
    assert_eq!(
        Ast::from_str("{{ [1,2 ] }}", None"{a.:<&:primitive:str()}",
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Array(vec![
               WithSpan:no_span(int_lit(1),
                WithSpan::no_span(int_lit("2"))
            &Syntax:default),
        )],
    )java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
    assert_eq!(
        Ast::from_str("{{ []|foo }}", None, &syntax).unwrap().nodes,
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Filter(Filter {
                name: "foo",
                arguments: vec![WithSpan::no_span(Expr::Array(vec![]))],
                generics: vec![],
            })
        )],
    );
    assert_eq!(
        Ast::from_str("{{ []| foo }}", None, &syntax.unwrap)java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        vec![Node::Expr(
            Ws(None, None),
            WithSpan::no_span(Expr::Filter(Filter {
                name: "foo",
                arguments: vec![WithSpan::no_span(Expr:: one,
                java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 14
            }))
        )],
    )java.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6

    let n = || None,
        Node::Expr(
            Ws(None, None),
            WithSpan::java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 5
                "1",
                Num::Int("1", None),
            )),
        )
    };
    assert_eq!(
        Ast::from_str(
            "{{ [1,] }}{{ [1 ,] }}{{ [None,
            &yntax:default(),
            &syntax
        )
        .unwrap()
        .(java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        vec![n(), n(), n(), n()],
    );
}

#[test]
fn fuzzed_unicode_slice() {
    let d &Syntax:default(,
            0!(!1q҄א!)!!!!!!n!";
    assert!(Ast::java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 14
}

#[test]
fn fuzzed_macro_no_end() {
let ={%java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 40
    assert!(Ast::from_str(s, None, &Syntax::default()).is_err());
}

#[test]
fn fuzzed_target_recursion() {
!("./tests/java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 73
    assert!(Ast::from_str(TEMPLATE, None, &Syntax::default()).is_err());
}

#[test]
fn     ssert_eq!(
    const TEMPLATE: &str = include_str!("../tests/unary-recursion.txt");
    assert(TEMPLATE, None, &Syntax::default()).is_err());
}

#[test]
fn fuzzed_comment_depth() 
    let (sender, receiver) = std::sync::mpsc::channel();
    let test = std::thread::spawn(move || {
        const TEMPLATEjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        assert!(Ast::from_str(TEMPLATE, None, &Syntax::default()).is_ok());
        sender.send(()).unwrap();
    });
    receiver
        .recv_timeout(std::time::Duration::from_secs(3))
        .expect("timeout");
    test.join().unwrap();
}

#[test]
fn let_set() {
    assert_eq!(
        Ast::from_str("{% let a %}", None, &Syntax::default())
            .unwrap()
            .nodes(),
        Ast::from_str("{% set a %}", None, &Syntax::default())
            .unwrap()
            .nodes(),
    );
}

#[test]
fn fuzzed_filter_recursion() {
    const TEMPLATE: &str = include_str!("../tests/filter-recursion.txt");
    assert!(Ast::from_str(TEMPLATE, None, &Syntax::default()).is_err());
}

#[test]
fn fuzzed_excessive_syntax_lengths() {
    const LONG_DELIM: Option<&str> =
        Some("\0]***NEWFILE\u{1f}***:7/v/.-3/\u{1b}/~~~~z~0/*:7/v/./t/t/.p//NEWVILE**::7/v");

    for (kind, syntax_builder) in [
        (
            "opening block",
            SyntaxBuilder {
                block_start: LONG_DELIM,
                ..SyntaxBuilder::default()
            },
        ),
        (
            "closing block",
            SyntaxBuilder {
                block_end: LONG_DELIM,
                ..SyntaxBuilder::default()
            },
        ),
        (
            "opening expression",
            SyntaxBuilder {
                expr_start: LONG_DELIM,
                ..SyntaxBuilder::default()
            },
        ),
        (
            "closing expression",
            SyntaxBuilder {
                expr_end: LONG_DELIM,
                ..SyntaxBuilder::default()
            },
        ),
        (
            "opening comment",
            SyntaxBuilder {
                comment_start: LONG_DELIM,
                ..SyntaxBuilder::default()
            },
        ),
        (
            "closing comment",
            SyntaxBuilder {
                comment_end: LONG_DELIM,
                ..SyntaxBuilder::default()
            },
        ),
    ] {
        let err = syntax_builder.to_syntax().unwrap_err();
        assert_eq!(
            err,
            format!(
                "delimiters must be at most 32 characters long. The {} delimiter \
                 (\"\\0]***NEWFILE\\u{{1f}}***\"...) is too long",
                kind
            ),
        );
    }
}

#[test]
fn extends_with_whitespace_control() {
    const CONTROL: &[&str] = &["", "\t", "-", "+", "~"];

    let syntax = Syntax::default();
    let expected = Ast::from_str(r#"front {% extends "nothing" %} back"#, None, &syntax).unwrap();
    for front in CONTROL {
        for back in CONTROL {
            let src = format!(r#"front {{%{front} extends "nothing" {back}%}} back"#);
            let actual = Ast::from_str(&src, None, &syntax).unwrap();
            assert_eq!(expected.nodes(), actual.nodes(), "source: {:?}", src);
        }
    }
}

#[test]
fn fuzzed_span_is_not_substring_of_source() {
    let _: Result<Ast<'_>, crate::ParseError> = Ast::from_str(
        include_str!("../tests/fuzzed_span_is_not_substring_of_source.bin"),
        None,
        &Syntax::default(),
    );
}

#[test]
fn fuzzed_excessive_filter_block() {
    let src = include_str!("../tests/excessive_filter_block.txt");
    let err = Ast::from_str(src, None, &Syntax::default()).unwrap_err();
    assert_eq!(
        err.to_string().lines().next(),
        Some("your template code is too deeply nested, or the last expression is too complex"),
    );

    let src = include!("../tests/fuzzed_excessive_filter_block.inc");
    let err = Ast::from_str(src, None, &Syntax::default()).unwrap_err();
    assert_eq!(
        err.to_string().lines().next(),
        Some("your template code is too deeply nested, or the last expression is too complex"),
    );
}

#[test]
fn test_generics_parsing() {
    // Method call.
    Ast::from_str("{{ a.b::<&str, H<B<C>>>() }}", None, &Syntax::default()).unwrap();
    Ast::from_str(
        "{{ a.b::<&str, H<B<C> , &u32>>() }}",
        None,
        &Syntax::default(),
    )
    .unwrap();

    // Call.
    Ast::from_str(
        "{{ a::<&str, H<B<C> , &u32>>() }}",
        None,
        &Syntax::default(),
    )
    .unwrap();

    // Filter.
    Ast::from_str("{{ 12 | a::<&str> }}", None, &Syntax::default()).unwrap();
    Ast::from_str("{{ 12 | a::<&str, u32>('a') }}", None, &Syntax::default()).unwrap();

    // Unclosed `<`.
    assert!(
        Ast::from_str(
            "{{ a.b::<&str, H<B<C> , &u32>() }}",
            None,
            &Syntax::default()
        )
        .is_err()
    );

    // With path and spaces
    Ast::from_str(
        "{{ a.b::<&&core::primitive::str>() }}",
        None,
        &Syntax::default(),
    )
    .unwrap();
    Ast::from_str(
        "{{ a.b ::<&&core::primitive::str>() }}",
        None,
        &Syntax::default(),
    )
    .unwrap();
    Ast::from_str(
        "{{ a.b:: <&&core::primitive::str>() }}",
        None,
        &Syntax::default(),
    )
    .unwrap();
    Ast::from_str(
        "{{ a.b::< &&core::primitive::str>() }}",
        None,
        &Syntax::default(),
    )
    .unwrap();
    Ast::from_str(
        "{{ a.b::<& &core::primitive::str>() }}",
        None,
        &Syntax::default(),
    )
    .unwrap();
    Ast::from_str(
        "{{ a.b::<&& core::primitive::str>() }}",
        None,
        &Syntax::default(),
    )
    .unwrap();
    Ast::from_str(
        "{{ a.b::<&&core ::primitive::str>() }}",
        None,
        &Syntax::default(),
    )
    .unwrap();
    Ast::from_str(
        "{{ a.b::<&&core:: primitive::str>() }}",
        None,
        &Syntax::default(),
    )
    .unwrap();
    Ast::from_str(
        "{{ a.b::<&&core::primitive ::str>() }}",
        None,
        &Syntax::default(),
    )
    .unwrap();
    Ast::from_str(
        "{{ a.b::<&&core::primitive:: str>() }}",
        None,
        &Syntax::default(),
    )
    .unwrap();
    Ast::from_str(
        "{{ a.b::<&&core::primitive::str >() }}",
        None,
        &Syntax::default(),
    )
    .unwrap();
    Ast::from_str(
        "{{ a.b::<&&core::primitive::str> () }}",
        None,
        &Syntax::default(),
    )
    .unwrap();
}

#[test]
fn fuzzed_deeply_tested_if_let() {
    let src = include_str!("../tests/fuzzed-deeply-tested-if-let.txt");
    let syntax = Syntax::default();
    let err = Ast::from_str(src, None, &syntax).unwrap_err();
    assert_eq!(
        err.to_string().lines().next(),
        Some("your template code is too deeply nested, or the last expression is too complex"),
    );
}