Grcov report - mod.rs

1

#![cfg(test)]

2

3

use lazy_static::lazy_static;

4

use proptest::prelude::*;

5

use proptest::string::string_regex;

6

use regex::escape;

7

8

mod char_stream_tests;

9

mod constant_parser_tests;

10

mod parser_tests;

11

mod preprocessor_tests;

12

mod scanner_tests;

13

mod source_map_tests;

14

15

lazy_static! {

16

    static ref SOURCE_CHAR_PATTERN: String = {

17

        // C17 [5.2.1] Character sets

18

        let upper_alpha = &('A'..='Z').collect::<String>();

19

        let lower_alpha = &('a'..='z').collect::<String>();

20

        let digits = &('0'..='9').collect::<String>();

21

        let graphic_chars = r###"!"#%&'()*+,-./:;<=>?[\]^_{|}~"###;

22

        let spaces = "\x20\t\n\r\x0b\x0c";

23

24

        [upper_alpha, lower_alpha, digits, graphic_chars, spaces].join("")

25

};

26

27

    static ref PRINTABLE_CHAR_PATTERN: String = {

28

        ('\x20'..='\x7e').collect::<_>()

29

};

30

31

32

5

fn identifier() -> impl Strategy<Value = String> {

33

5

    string_regex("[_a-zA-Z][_0-9a-zA-Z]*")

34

5

        .unwrap()

35

1294

        .prop_filter("must not be a keyword", |ident| !is_keyword(ident))

36

5

37

38

1294

fn is_keyword(lexeme: &str) -> bool {

39

    matches!(

40

1294

        lexeme,

41

1294

        "auto"

42

1294

            | "break"

43

1294

            | "case"

44

1294

            | "char"

45

1294

            | "const"

46

1294

            | "continue"

47

1294

            | "default"

48

1294

            | "do"

49

1294

            | "double"

50

1294

            | "else"

51

1294

            | "enum"

52

1294

            | "extern"

53

1294

            | "float"

54

1294

            | "for"

55

1294

            | "goto"

56

1294

            | "if"

57

1294

            | "inline"

58

1294

            | "int"

59

1294

            | "long"

60

1294

            | "register"

61

1294

            | "restrict"

62

1294

            | "return"

63

1294

            | "short"

64

1294

            | "signed"

65

1294

            | "sizeof"

66

1294

            | "static"

67

1294

            | "struct"

68

1294

            | "switch"

69

1294

            | "typedef"

70

1294

            | "union"

71

1294

            | "unsigned"

72

1294

            | "void"

73

1294

            | "volatile"

74

1294

            | "while"

75

1294

            | "_Alignas"

76

1294

            | "_Alignof"

77

1294

            | "_Atomic"

78

1294

            | "_Bool"

79

1294

            | "_Complex"

80

1294

            | "_Generic"

81

1294

            | "_Imaginary"

82

1294

            | "_Noreturn"

83

1294

            | "_Static_assert"

84

1294

            | "_Thread_local",

85

86

1294

87

88

2

pub fn source_char() -> impl Strategy<Value = String> {

89

2

    string_regex(&format!("[{}]", escape(&SOURCE_CHAR_PATTERN))).unwrap()

90

2

91

92

3

pub fn source_chars() -> impl Strategy<Value = String> {

93

3

    string_regex(&format!("[{}]+", escape(&SOURCE_CHAR_PATTERN))).unwrap()

94

3

95

96

4

pub fn source_chars_except(excluded_chars: &[char]) -> impl Strategy<Value = String> {

97

4

    string_regex(&format!(

98

4

        "[{}]+",

99

4

        escape(&SOURCE_CHAR_PATTERN.replace(excluded_chars, ""))

100

4

))

101

4

    .unwrap()

102

4

103

104

1

pub fn non_source_char() -> impl Strategy<Value = String> {

105

1

    string_regex(&format!("[^{}\0]", escape(&SOURCE_CHAR_PATTERN))).unwrap()

106

1

107

108

2

pub fn printable_chars() -> impl Strategy<Value = String> {

109

2

    printable_chars_except(&[])

110

2

111

112

2

pub fn printable_chars_except(excluded_chars: &[char]) -> impl Strategy<Value = String> {

113

2

    string_regex(&format!(

114

2

        "[{}]+",

115

2

        &escape(&PRINTABLE_CHAR_PATTERN.replace(excluded_chars, ""))

116

2

))

117

2

    .unwrap()

118

2

119

120

1

pub fn whitespace() -> impl Strategy<Value = String> {

121

1

    let spaces = "\x20\t\n\r\x0b\x0c";

122

1

123

1

    string_regex(&format!("[{}]+", spaces)).unwrap()

124

1

125

126

1

pub fn newline() -> impl Strategy<Value = String> {

127

1

    string_regex("\n|\r|\n\r|\r\n").unwrap()

128

1

129

130

1

pub fn source_punctuation() -> impl Strategy<Value = String> {

131

1

    string_regex(&format!("[{}]", escape(r"!#%&()*+,-./:;<=>?[]^{|}~"))).unwrap()

132

1

133

134

260

pub fn is_start_of_prefixed_char_const_or_str_lit(text: &str) -> bool {

135

260

    use regex::Regex;

136

260

137

260

    Regex::new(r#"^[uUL]'|(u8|[uUL])""#).unwrap().is_match(text)

138

260