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
77
78
79
80
81
82

use logical_expression_parser::*;
use pest::Parser;

#[test]
fn test_rule_binary_digit() {
    let input = "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_rule_unary_not() {
    let input = "!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_rule_logical_and() {
    let input = "1 && 1";
    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_rule_logical_or() {
    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(), true);
}

#[test]
fn test_rule_implication() {
    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_rule_equivalence() {
    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_rule_xor() {
    let input = "1 xor 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_rule_primary() {
    let input = "!(!(1)) && 1";
    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_rule_atom() {
    let input = "!(!(1))";
    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_rule_expr() {
    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);
}