logical_expression_parser 0.1.1

This is a simple logical expression parser written in Rust using pest library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use logical_expression_parser::*;

#[test]
fn test_parse_expr() {
    let line = 1.to_string();
    let parse_result = CalculatorParser::parse(Rule::equation, &line);
    match parse_result {
        Ok(mut pairs) => {
            let parsed_expr = parse_expr(pairs.next().unwrap().into_inner());
            let result = parsed_expr.evaluate();
            assert_eq!(result, true);
        }
        Err(e) => {
            eprintln!("Parse failed: {:?}", e);
        }
    }
}

#[test]
fn test_parse_expr1() {
    let input = "1 && 0";
    let mut pairs = CalculatorParser::parse(Rule::equation, input).expect("Parse failed");
    let parsed_expr = parse_expr(pairs.next().unwrap().into_inner());
    assert_eq!(parsed_expr.evaluate(), false);
}

#[test]
fn test_parse_expr2() {
    let input = "0 && 1 -> !1 || 0 && 0";
    let mut pairs = CalculatorParser::parse(Rule::equation, input).expect("Parse failed");
    let parsed_expr = parse_expr(pairs.next().unwrap().into_inner());
    assert_eq!(parsed_expr.evaluate(), true);
}

#[test]
fn test_parse_expr3() {
    let input = "(0 && 1 -> !1 || 0) && 0";
    let mut pairs = CalculatorParser::parse(Rule::equation, input).expect("Parse failed");
    let parsed_expr = parse_expr(pairs.next().unwrap().into_inner());
    assert_eq!(parsed_expr.evaluate(), false);
}

#[test]
fn test_parse_error_handling() {
    let input = "invalid_input";

    let parse_result = CalculatorParser::parse(Rule::equation, input);

    assert!(parse_result.is_err());
}

#[test]
fn test_parse_expr_complex_expression() {
    let input = CalculatorParser::parse(Rule::expr, "0 && 1 -> !1 || 0 && 0").unwrap();
    let expr = parse_expr(input);

    let expected_expr = Expr::LogicalOp {
        lhs: Box::new(Expr::LogicalOp {
            lhs: Box::new(Expr::Integer(0)),
            op: Op::LogicalAnd,
            rhs: Box::new(Expr::Integer(1)),
        }),
        op: Op::Implication,
        rhs: Box::new(Expr::LogicalOp {
            lhs: Box::new(Expr::UnaryNot(Box::new(Expr::Integer(1)))),
            op: Op::LogicalOr,
            rhs: Box::new(Expr::LogicalOp {
                lhs: Box::new(Expr::Integer(0)),
                op: Op::LogicalAnd,
                rhs: Box::new(Expr::Integer(0)),
            }),
        }),
    };

    assert_eq!(expr, expected_expr);
}