control_parser_tests.rs

// Copyright (c) 2020 Ghaith Hachem and Mathias Rieder
use crate::ast::Statement;
use crate::parser::parse;
use pretty_assertions::*;

#[test]
fn if_statement() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        IF TRUE THEN
        END_IF
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"IfStatement {
    blocks: [
        ConditionalBlock {
            condition: LiteralBool {
                value: true,
            },
            body: [],
        },
    ],
    else_block: [],
}"#;
    assert_eq!(ast_string, expected_ast);
}

#[test]
fn test_return_statement() {
    let lexer = super::lex("PROGRAM ret RETURN END_PROGRAM");
    let result = parse(lexer).0;
    let prg = &result.implementations[0];
    let stmt = &prg.statements[0];

    assert_eq!(format!("{:?}", stmt), "ReturnStatement");
}

#[test]
fn if_else_statement_with_expressions() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        IF TRUE THEN
            x;
        ELSE
            y;
        END_IF
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"IfStatement {
    blocks: [
        ConditionalBlock {
            condition: LiteralBool {
                value: true,
            },
            body: [
                Reference {
                    name: "x",
                },
            ],
        },
    ],
    else_block: [
        Reference {
            name: "y",
        },
    ],
}"#;
    assert_eq!(ast_string, expected_ast);
}

#[test]
fn if_elsif_elsif_else_statement_with_expressions() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        IF TRUE THEN
            x;
        ELSIF y THEN
            z;
        ELSIF w THEN
            v;
        ELSE
            u;
        END_IF
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"IfStatement {
    blocks: [
        ConditionalBlock {
            condition: LiteralBool {
                value: true,
            },
            body: [
                Reference {
                    name: "x",
                },
            ],
        },
        ConditionalBlock {
            condition: Reference {
                name: "y",
            },
            body: [
                Reference {
                    name: "z",
                },
            ],
        },
        ConditionalBlock {
            condition: Reference {
                name: "w",
            },
            body: [
                Reference {
                    name: "v",
                },
            ],
        },
    ],
    else_block: [
        Reference {
            name: "u",
        },
    ],
}"#;
    assert_eq!(ast_string, expected_ast);
}

#[test]
fn for_with_literals_statement() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        FOR y := x TO 10 DO
        END_FOR
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"ForLoopStatement {
    counter: Reference {
        name: "y",
    },
    start: Reference {
        name: "x",
    },
    end: LiteralInteger {
        value: 10,
    },
    by_step: None,
    body: [],
}"#;
    assert_eq!(ast_string, expected_ast);
}

#[test]
fn for_with_step_statement() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        FOR x := 1 TO 10 BY 7 DO 
        END_FOR
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"ForLoopStatement {
    counter: Reference {
        name: "x",
    },
    start: LiteralInteger {
        value: 1,
    },
    end: LiteralInteger {
        value: 10,
    },
    by_step: Some(
        LiteralInteger {
            value: 7,
        },
    ),
    body: [],
}"#;
    assert_eq!(ast_string, expected_ast);
}

#[test]
fn for_with_reference_statement() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        FOR z := x TO y DO
        END_FOR
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"ForLoopStatement {
    counter: Reference {
        name: "z",
    },
    start: Reference {
        name: "x",
    },
    end: Reference {
        name: "y",
    },
    by_step: None,
    body: [],
}"#;
    assert_eq!(ast_string, expected_ast);
}

#[test]
fn for_with_body_statement() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        FOR z := x TO y DO
            x;
            y;
        END_FOR
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"ForLoopStatement {
    counter: Reference {
        name: "z",
    },
    start: Reference {
        name: "x",
    },
    end: Reference {
        name: "y",
    },
    by_step: None,
    body: [
        Reference {
            name: "x",
        },
        Reference {
            name: "y",
        },
    ],
}"#;
    assert_eq!(ast_string, expected_ast);
}

#[test]
fn while_with_literal() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        WHILE TRUE DO
        END_WHILE
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"WhileLoopStatement {
    condition: LiteralBool {
        value: true,
    },
    body: [],
}"#;
    assert_eq!(ast_string, expected_ast);
}

#[test]
fn while_with_expression() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        WHILE x < 7 DO 
        END_WHILE
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"WhileLoopStatement {
    condition: BinaryExpression {
        operator: Less,
        left: Reference {
            name: "x",
        },
        right: LiteralInteger {
            value: 7,
        },
    },
    body: [],
}"#;
    assert_eq!(ast_string, expected_ast);
}

#[test]
fn while_with_body_statement() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        WHILE TRUE DO
            x;
            y;
        END_WHILE
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"WhileLoopStatement {
    condition: LiteralBool {
        value: true,
    },
    body: [
        Reference {
            name: "x",
        },
        Reference {
            name: "y",
        },
    ],
}"#;

    assert_eq!(ast_string, expected_ast);
}

#[test]
fn repeat_with_literal() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        REPEAT
        UNTIL TRUE
        END_REPEAT
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"RepeatLoopStatement {
    condition: LiteralBool {
        value: true,
    },
    body: [],
}"#;
    assert_eq!(ast_string, expected_ast);
}

#[test]
fn repeat_with_expression() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        REPEAT
        UNTIL x > 7
        END_REPEAT
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"RepeatLoopStatement {
    condition: BinaryExpression {
        operator: Greater,
        left: Reference {
            name: "x",
        },
        right: LiteralInteger {
            value: 7,
        },
    },
    body: [],
}"#;
    assert_eq!(ast_string, expected_ast);
}

#[test]
fn repeat_with_body_statement() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        REPEAT
            x;
            y;
        UNTIL TRUE
        END_REPEAT
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"RepeatLoopStatement {
    condition: LiteralBool {
        value: true,
    },
    body: [
        Reference {
            name: "x",
        },
        Reference {
            name: "y",
        },
    ],
}"#;

    assert_eq!(ast_string, expected_ast);
}

#[test]
fn case_statement_with_one_condition() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        CASE StateMachine OF
        1: x;
        END_CASE
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"CaseStatement {
    selector: Reference {
        name: "StateMachine",
    },
    case_blocks: [
        ConditionalBlock {
            condition: LiteralInteger {
                value: 1,
            },
            body: [
                Reference {
                    name: "x",
                },
            ],
        },
    ],
    else_block: [],
}"#;

    assert_eq!(ast_string, expected_ast);
}

#[test]
fn case_statement_with_else_and_no_condition() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        CASE StateMachine OF
        ELSE
        END_CASE
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"CaseStatement {
    selector: Reference {
        name: "StateMachine",
    },
    case_blocks: [],
    else_block: [],
}"#;

    assert_eq!(ast_string, expected_ast);
}

#[test]
fn case_statement_with_no_conditions() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        CASE StateMachine OF
        END_CASE
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"CaseStatement {
    selector: Reference {
        name: "StateMachine",
    },
    case_blocks: [],
    else_block: [],
}"#;

    assert_eq!(ast_string, expected_ast);
}

#[test]
fn case_statement_with_one_condition_and_an_else() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        CASE StateMachine OF
        1: x;
        ELSE
            y;
        END_CASE
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"CaseStatement {
    selector: Reference {
        name: "StateMachine",
    },
    case_blocks: [
        ConditionalBlock {
            condition: LiteralInteger {
                value: 1,
            },
            body: [
                Reference {
                    name: "x",
                },
            ],
        },
    ],
    else_block: [
        Reference {
            name: "y",
        },
    ],
}"#;

    assert_eq!(ast_string, expected_ast);
}

#[test]
fn case_statement_with_one_empty_condition_and_an_else() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        CASE StateMachine OF
        1:
        ELSE
            y;
        END_CASE
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"CaseStatement {
    selector: Reference {
        name: "StateMachine",
    },
    case_blocks: [
        ConditionalBlock {
            condition: LiteralInteger {
                value: 1,
            },
            body: [],
        },
    ],
    else_block: [
        Reference {
            name: "y",
        },
    ],
}"#;

    assert_eq!(ast_string, expected_ast);
}

#[test]
fn case_statement_with_multiple_conditions() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        CASE StateMachine OF
            1: x;
            2: y; yy; yyy;
            3: z;
        END_CASE
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"CaseStatement {
    selector: Reference {
        name: "StateMachine",
    },
    case_blocks: [
        ConditionalBlock {
            condition: LiteralInteger {
                value: 1,
            },
            body: [
                Reference {
                    name: "x",
                },
            ],
        },
        ConditionalBlock {
            condition: LiteralInteger {
                value: 2,
            },
            body: [
                Reference {
                    name: "y",
                },
                Reference {
                    name: "yy",
                },
                Reference {
                    name: "yyy",
                },
            ],
        },
        ConditionalBlock {
            condition: LiteralInteger {
                value: 3,
            },
            body: [
                Reference {
                    name: "z",
                },
            ],
        },
    ],
    else_block: [],
}"#;

    assert_eq!(ast_string, expected_ast);
}

#[test]
fn case_statement_with_multiple_expressions_per_condition() {
    let lexer = super::lex(
        "
        PROGRAM exp 
        CASE StateMachine OF
            1,2,3: x;
            4..5, 6: y;
        END_CASE
        END_PROGRAM
        ",
    );
    let result = parse(lexer).0;

    let prg = &result.implementations[0];
    let statement = &prg.statements[0];

    let ast_string = format!("{:#?}", statement);
    let expected_ast = r#"CaseStatement {
    selector: Reference {
        name: "StateMachine",
    },
    case_blocks: [
        ConditionalBlock {
            condition: ExpressionList {
                expressions: [
                    LiteralInteger {
                        value: 1,
                    },
                    LiteralInteger {
                        value: 2,
                    },
                    LiteralInteger {
                        value: 3,
                    },
                ],
            },
            body: [
                Reference {
                    name: "x",
                },
            ],
        },
        ConditionalBlock {
            condition: ExpressionList {
                expressions: [
                    RangeStatement {
                        start: LiteralInteger {
                            value: 4,
                        },
                        end: LiteralInteger {
                            value: 5,
                        },
                    },
                    LiteralInteger {
                        value: 6,
                    },
                ],
            },
            body: [
                Reference {
                    name: "y",
                },
            ],
        },
    ],
    else_block: [],
}"#;

    assert_eq!(ast_string, expected_ast);
}

#[test]
fn if_stmnt_location_test() {
    let source = "
    PROGRAM prg 
    IF a > 4 THEN
        a + b;
    ELSIF x < 2 THEN
        b + c;
    END_IF
    END_PROGRAM";

    let lexer = super::lex(source);
    let parse_result = parse(lexer).0;

    let unit = &parse_result.implementations[0];

    let location = &unit.statements[0].get_location();
    assert_eq!(
        source[location.get_start()..location.get_end()].to_string(),
        "IF a > 4 THEN
        a + b;
    ELSIF x < 2 THEN
        b + c;
    END_IF"
    );

    if let Statement::IfStatement { blocks, .. } = &unit.statements[0] {
        let if_location = blocks[0].condition.as_ref().get_location();
        assert_eq!(
            source[if_location.get_start()..if_location.get_end()].to_string(),
            "a > 4"
        );

        let elsif_location = blocks[1].condition.as_ref().get_location();
        assert_eq!(
            source[elsif_location.get_start()..elsif_location.get_end()].to_string(),
            "x < 2"
        );
    }
}

#[test]
fn for_stmnt_location_test() {
    let source = "
    PROGRAM prg 
    FOR x := 3 TO 9 BY 2 DO
        a + b;
    END_FOR
    END_PROGRAM";

    let lexer = super::lex(source);
    let parse_result = parse(lexer).0;

    let unit = &parse_result.implementations[0];

    let location = &unit.statements[0].get_location();
    assert_eq!(
        source[location.get_start()..location.get_end()].to_string(),
        "FOR x := 3 TO 9 BY 2 DO
        a + b;
    END_FOR"
    );

    if let Statement::ForLoopStatement {
        counter,
        start,
        end,
        by_step,
        ..
    } = &unit.statements[0]
    {
        let counter_location = counter.as_ref().get_location();
        assert_eq!(
            source[counter_location.get_start()..counter_location.get_end()].to_string(),
            "x"
        );

        let start_location = start.as_ref().get_location();
        assert_eq!(
            source[start_location.get_start()..start_location.get_end()].to_string(),
            "3"
        );

        let end_location = end.as_ref().get_location();
        assert_eq!(
            source[end_location.get_start()..end_location.get_end()].to_string(),
            "9"
        );

        let by_location = by_step
            .as_ref()
            .map(|it| it.as_ref().get_location())
            .unwrap();
        assert_eq!(
            source[by_location.get_start()..by_location.get_end()].to_string(),
            "2"
        );
    } else {
        panic!("expected ForLoopStatement")
    }
}

#[test]
fn while_stmnt_location_test() {
    let source = "
    PROGRAM prg 
    WHILE a < 2 DO
        a := a - 1;
    END_WHILE
    END_PROGRAM";

    let lexer = super::lex(source);
    let parse_result = parse(lexer).0;

    let unit = &parse_result.implementations[0];

    let location = &unit.statements[0].get_location();
    assert_eq!(
        source[location.get_start()..location.get_end()].to_string(),
        "WHILE a < 2 DO
        a := a - 1;
    END_WHILE"
    );
}

#[test]
fn case_stmnt_location_test() {
    let source = "
    PROGRAM prg 
    CASE a OF
    1:
        a := a - 1;
    2:
        a := a - 1;
    END_CASE
    END_PROGRAM";

    let lexer = super::lex(source);
    let parse_result = parse(lexer).0;

    let unit = &parse_result.implementations[0];

    let location = &unit.statements[0].get_location();
    assert_eq!(
        source[location.get_start()..location.get_end()].to_string(),
        "CASE a OF
    1:
        a := a - 1;
    2:
        a := a - 1;
    END_CASE"
    );
}

#[test]
fn call_stmnt_location_test() {
    let source = "
    PROGRAM prg 
    foo(a:=3, b:=4);
    END_PROGRAM";

    let lexer = super::lex(source);
    let parse_result = parse(lexer).0;

    let unit = &parse_result.implementations[0];

    let location = &unit.statements[0].get_location();
    assert_eq!(
        source[location.get_start()..location.get_end()].to_string(),
        "foo(a:=3, b:=4)"
    );

    if let Statement::CallStatement {
        operator,
        parameters,
        ..
    } = &unit.statements[0]
    {
        let operator_location = operator.as_ref().get_location();
        assert_eq!(
            source[operator_location.get_start()..operator_location.get_end()].to_string(),
            "foo"
        );

        let parameters_statement = parameters.as_ref().as_ref();
        let parameters_location = parameters_statement.map(|it| it.get_location()).unwrap();
        assert_eq!(
            source[parameters_location.get_start()..parameters_location.get_end()].to_string(),
            "a:=3, b:=4"
        );
    }
}