Grcov report - semantic

1

use conjure_cp_essence_parser::diagnostics::diagnostics_api::get_diagnostics;

2

use conjure_cp_essence_parser::diagnostics::error_detection::collect_errors::check_diagnostic;

3

use conjure_cp_essence_parser::util::get_tree;

4

5

#[test]

6

1

fn detects_undefined_variable() {

7

1

    let source = "find x: int(1..10)\nsuch that x = y";

8

    // y is undefined

9

1

    let (cst, _) = get_tree(&source).unwrap();

10

1

    let diagnostics = get_diagnostics(&source, &cst);

11

12

1

    assert_eq!(

13

1

        diagnostics.len(),

14

1,

15

        "Expected exactly one diagnostic for undefined variable"

16

);

17

18

1

    let diag = &diagnostics[0];

19

20

1

    check_diagnostic(diag, 1, 14, 1, 15, "The identifier 'y' is not defined");

21

1

22

23

#[test]

24

1

fn no_errors_for_valid_code() {

25

1

    let source = "find x, y: int(1..10)\nsuch that x + y = 10";

26

1

    let (cst, _) = get_tree(&source).unwrap();

27

28

1

    let diagnostics = get_diagnostics(&source, &cst);

29

30

    // should have no diagnostics

31

1

    assert_eq!(

32

1

        diagnostics.len(),

33

0,

34

        "Expected no diagnostics for valid code, got: {:?}",

35

        diagnostics

36

);

37

1

38

39

#[test]

40

1

fn range_points_to_error_location() {

41

1

    let source = "find x: int(1..10)\nsuch that x = undefined_var";

42

1

    let (cst, _) = get_tree(&source).unwrap();

43

44

1

    let diagnostics = get_diagnostics(&source, &cst);

45

46

1

    assert_eq!(

47

1

        diagnostics.len(),

48

1,

49

        "Expected exactly one diagnostic for undefined variable"

50

);

51

52

1

    let diag = &diagnostics[0];

53

54

1

    check_diagnostic(

55

1

        diag,

56

1,

57

14,

58

1,

59

27,

60

1

        "The identifier 'undefined_var' is not defined",

61

);

62

1

63

64

// not enforced in conjure

65

#[ignore]

66

#[test]

67

fn domain_start_greater_than_end() {

68

    let source = "find x: int(10..1)";

69

    let (cst, _) = get_tree(&source).unwrap();

70

71

    let diagnostics = get_diagnostics(&source, &cst);

72

73

    assert_eq!(

74

        diagnostics.len(),

75

1,

76

        "Expected exactly one diagnostic for undefined variable"

77

);

78

79

    let diag = &diagnostics[0];

80

81

    check_diagnostic(

82

        diag,

83

0,

84

12,

85

0,

86

17,

87

        "Start value greater than end value in 'domain'",

88

);

89

90

91

#[ignore]

92

#[test]

93

fn incorrect_type_for_equation() {

94

    let source = "

95

    letting y be false\n

96

    find x: int(5..10)\n

97

    such that 5 + y = 6";

98

    let (cst, _) = get_tree(&source).unwrap();

99

100

    let diagnostics = get_diagnostics(&source, &cst);

101

102

    assert_eq!(

103

        diagnostics.len(),

104

1,

105

        "Expected exactly one diagnostic for undefined variable"

106

);

107

108

    let diag = &diagnostics[0];

109

110

    check_diagnostic(

111

        diag,

112

2,

113

14,

114

2,

115

15,

116

        "Incorrect type 'bool' for variable 'y', expected 'int'",

117

);

118

119

120

#[ignore]

121

#[test]

122

fn dividing_over_zero() {

123

    let source = "find x: int(5..10)\nsuch that x/0 = 3";

124

    let (cst, _) = get_tree(&source).unwrap();

125

126

    let diagnostics = get_diagnostics(&source, &cst);

127

128

    assert_eq!(

129

        diagnostics.len(),

130

1,

131

        "Expected exactly one diagnostic for undefined variable"

132

);

133

134

    let diag = &diagnostics[0];

135

136

    check_diagnostic(diag, 1, 10, 1, 13, "Unsafe division attempted");

137

138

139

#[ignore]

140

#[test]

141

fn invalid_index() {

142

    let source = "letting s be (0,1,1,0)

143

                \nletting t be (0,0,0,1)

144

                \nfind a : bool such that a = (s[5] = t[1])";

145

    let (cst, _) = get_tree(&source).unwrap();

146

147

    let diagnostics = get_diagnostics(&source, &cst);

148

149

    assert_eq!(

150

        diagnostics.len(),

151

1,

152

        "Expected exactly one diagnostic for undefined variable"

153

);

154

155

    let diag = &diagnostics[0];

156

157

    check_diagnostic(diag, 2, 31, 2, 32, "Index out of bounds");

158

159

160

#[ignore]

161

#[test]

162

fn duplicate_declaration_of_variable() {

163

    let source = "find x: int(1..10)\nfind x: int(2..3)";

164

    let (cst, _) = get_tree(&source).unwrap();

165

166

    let diagnostics = get_diagnostics(&source, &cst);

167

168

    assert_eq!(

169

        diagnostics.len(),

170

1,

171

        "Expected exactly one diagnostic for undefined variable"

172

);

173

174

    let diag = &diagnostics[0];

175

176

    check_diagnostic(

177

        diag,

178

1,

179

5,

180

1,

181

6,

182

        "Redeclaration of variable 'x' which was previously defined",

183

);

184

185

186

#[ignore]

187

#[test]

188

fn extra_comma_in_variable_list() {

189

    let source = "find x,: int(1..10)";

190

    let (cst, _) = get_tree(&source).unwrap();

191

192

    let diagnostics = get_diagnostics(&source, &cst);

193

194

    assert_eq!(

195

        diagnostics.len(),

196

1,

197

        "Expected exactly one diagnostic for undefined variable"

198

);

199

200

    let diag = &diagnostics[0];

201

202

    check_diagnostic(

203

        diag,

204

0,

205

6,

206

0,

207

7,

208

        "Semantic Error: Extra ',' at the end of 'variable_list'",

209

);

210