Grcov report - grammar

1

use indoc::indoc;

2

use pest::Parser;

3

4

use merc_syntax::Mcrl2Parser;

5

use merc_syntax::Rule;

6

use merc_syntax::UntypedProcessSpecification;

7

use merc_syntax::UntypedStateFrmSpec;

8

use merc_syntax::parse_sortexpr;

9

use merc_utilities::test_logger;

10

11

#[test]

12

1

fn test_parse_ifthen() {

13

1

    let expr = "init a -> b <> b;";

14

15

1

    match UntypedProcessSpecification::parse(expr) {

16

1

        Ok(result) => {

17

1

            println!("{}", result);

18

1

19

        Err(e) => {

20

            panic!("Failed to parse expression: {}", e);

21

22

23

1

24

25

#[test]

26

1

fn test_parse_keywords() {

27

1

    let expr = "map or : Boolean # Boolean -> Boolean ;";

28

29

1

    match UntypedProcessSpecification::parse(expr) {

30

1

        Ok(result) => {

31

1

            println!("{}", result);

32

1

33

        Err(e) => {

34

            panic!("Failed to parse expression: {}", e);

35

36

37

1

38

39

#[test]

40

1

fn test_parse_sort_spec() {

41

1

    let sort_spec = indoc! {"

42

1

        sort D = Bool -> Int -> Bool;

43

1

44

1

45

1

        % Test

46

1

        F     = struct d1 | d2;

47

1

        Error = struct e;

48

1

"};

49

50

1

    match UntypedProcessSpecification::parse(sort_spec) {

51

1

        Ok(result) => {

52

1

            println!("{}", result);

53

1

54

        Err(e) => {

55

            panic!("Failed to parse expression: {}", e);

56

57

58

1

59

60

#[test]

61

1

fn test_parse_regular_expression() {

62

1

    let spec = "[true++false]true";

63

64

1

    match UntypedStateFrmSpec::parse(spec) {

65

1

        Ok(result) => {

66

1

            println!("{}", result);

67

1

68

        Err(e) => {

69

            panic!("Failed to parse expression: {}", e);

70

71

72

1

73

74

#[test]

75

1

fn test_parse_procexpr() {

76

1

    test_logger();

77

78

    use indoc::indoc;

79

80

1

    let spec: &str = indoc! {"init

81

1

        true -> delta <> delta;

82

1

"};

83

84

1

    match UntypedProcessSpecification::parse(spec) {

85

1

        Ok(result) => {

86

1

            println!("{}", result);

87

1

88

        Err(e) => {

89

            panic!("Failed to parse expression: {}", e);

90

91

92

1

93

94

#[test]

95

1

fn test_parse_statefrm() {

96

1

    test_logger();

97

98

    use indoc::indoc;

99

100

1

    let spec: &str = indoc! {"<b> <a> exists b: Bool . b && !b"};

101

102

1

    match UntypedStateFrmSpec::parse(spec) {

103

1

        Ok(result) => {

104

1

            println!("{}", result);

105

1

106

        Err(e) => {

107

            panic!("Failed to parse expression: {}", e);

108

109

110

1

111

112

#[test]

113

1

fn test_sort_precedence() {

114

1

    let term = "Bool # Int -> Int -> Bool";

115

116

1

    match Mcrl2Parser::parse(Rule::SortExpr, term) {

117

1

        Ok(result) => {

118

1

            print!("{}", parse_sortexpr(result).unwrap());

119

1

120

        Err(e) => {

121

            panic!("{}", e);

122

123

124

1

125

126

// #[test]

127

// fn test_bool_spec() {

128

//     match UntypedDataSpecification::parse(include_str!("../spec/bool.mcrl2")) {

129

//         Ok(result) => {

130

//             println!("{}", result);

131

//         }

132

//         Err(e) => {

133

//             panic!("Failed to parse expression: {}", e);

134

//         }

135

//     }

136

// }