Grcov report - grammar

1

use indoc::indoc;

2

use merc_syntax::UntypedDataSpecification;

3

use pest::Parser;

4

5

use merc_syntax::Mcrl2Parser;

6

use merc_syntax::Rule;

7

use merc_syntax::UntypedProcessSpecification;

8

use merc_syntax::UntypedStateFrmSpec;

9

use merc_syntax::parse_sortexpr;

10

use merc_utilities::test_logger;

11

12

#[test]

13

1

fn test_parse_ifthen() {

14

1

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

15

16

1

    match UntypedProcessSpecification::parse(expr) {

17

1

        Ok(result) => {

18

1

            println!("{}", result);

19

1

20

        Err(e) => {

21

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

22

23

24

1

25

26

#[test]

27

1

fn test_parse_keywords() {

28

1

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

29

30

1

    match UntypedProcessSpecification::parse(expr) {

31

1

        Ok(result) => {

32

1

            println!("{}", result);

33

1

34

        Err(e) => {

35

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

36

37

38

1

39

40

#[test]

41

1

fn test_parse_sort_spec() {

42

1

    let sort_spec = indoc! {"

43

1

        sort D = Bool -> Int -> Bool;

44

1

45

1

46

1

        % Test

47

1

        F     = struct d1 | d2;

48

1

        Error = struct e;

49

1

"};

50

51

1

    match UntypedProcessSpecification::parse(sort_spec) {

52

1

        Ok(result) => {

53

1

            println!("{}", result);

54

1

55

        Err(e) => {

56

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

57

58

59

1

60

61

#[test]

62

1

fn test_parse_regular_expression() {

63

1

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

64

65

1

    match UntypedStateFrmSpec::parse(spec) {

66

1

        Ok(result) => {

67

1

            println!("{}", result);

68

1

69

        Err(e) => {

70

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

71

72

73

1

74

75

#[test]

76

1

fn test_parse_procexpr() {

77

1

    test_logger();

78

79

    use indoc::indoc;

80

81

1

    let spec: &str = indoc! {"init

82

1

        true -> delta <> delta;

83

1

"};

84

85

1

    match UntypedProcessSpecification::parse(spec) {

86

1

        Ok(result) => {

87

1

            println!("{}", result);

88

1

89

        Err(e) => {

90

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

91

92

93

1

94

95

#[test]

96

1

fn test_parse_statefrm() {

97

1

    test_logger();

98

99

    use indoc::indoc;

100

101

1

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

102

103

1

    match UntypedStateFrmSpec::parse(spec) {

104

1

        Ok(result) => {

105

1

            println!("{}", result);

106

1

107

        Err(e) => {

108

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

109

110

111

1

112

113

#[test]

114

1

fn test_sort_precedence() {

115

1

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

116

117

1

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

118

1

        Ok(result) => {

119

1

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

120

1

121

        Err(e) => {

122

            panic!("{}", e);

123

124

125

1

126

127

#[test]

128

1

fn test_bool_spec() {

129

1

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

130

1

        Ok(result) => {

131

1

            println!("{}", result);

132

1

133

        Err(e) => {

134

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

135

136

137

1

138

139

#[test]

140

1

fn test_int_spec() {

141

1

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

142

1

        Ok(result) => {

143

1

            println!("{}", result);

144

1

145

        Err(e) => {

146

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

147

148

149

1

150

151

#[test]

152

1

fn test_nat_spec() {

153

1

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

154

1

        Ok(result) => {

155

1

            println!("{}", result);

156

1

157

        Err(e) => {

158

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

159

160

161

1

162

163

#[test]

164

1

fn test_pos_spec() {

165

1

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

166

1

        Ok(result) => {

167

1

            println!("{}", result);

168

1

169

        Err(e) => {

170

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

171

172

173

1

174

175

#[test]

176

1

fn test_real_spec() {

177

1

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

178

1

        Ok(result) => {

179

1

            println!("{}", result);

180

1

181

        Err(e) => {

182

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

183

184

185

1

186

187

#[test]

188

1

fn test_list_spec() {

189

1

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

190

1

        Ok(result) => {

191

1

            println!("{}", result);

192

1

193

        Err(e) => {

194

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

195

196

197

1

198

199

#[test]

200

1

fn test_set_spec() {

201

1

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

202

1

        Ok(result) => {

203

1

            println!("{}", result);

204

1

205

        Err(e) => {

206

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

207

208

209

1

210

211

#[test]

212

1

fn test_fset_spec() {

213

1

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

214

1

        Ok(result) => {

215

1

            println!("{}", result);

216

1

217

        Err(e) => {

218

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

219

220

221

1

222

223

#[test]

224

1

fn test_bag_spec() {

225

1

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

226

1

        Ok(result) => {

227

1

            println!("{}", result);

228

1

229

        Err(e) => {

230

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

231

232

233

1

234

235

#[test]

236

1

fn test_fbag_spec() {

237

1

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

238

1

        Ok(result) => {

239

1

            println!("{}", result);

240

1

241

        Err(e) => {

242

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

243

244

245

1