src/librustc_lexer/src/tests.rs

   1 #[cfg(test)]
   2 mod tests {
   3     use crate::*;
   4
   5     fn check_raw_str(
   6         s: &str,
   7         expected: UnvalidatedRawStr,
   8         validated: Result<ValidatedRawStr, LexRawStrError>,
   9     ) {
  10         let s = &format!("r{}", s);
  11         let mut cursor = Cursor::new(s);
  12         cursor.bump();
  13         let tok = cursor.raw_double_quoted_string(0);
  14         assert_eq!(tok, expected);
  15         assert_eq!(tok.validate(), validated);
  16     }
  17
  18     #[test]
  19     fn test_naked_raw_str() {
  20         check_raw_str(
  21             r#""abc""#,
  22             UnvalidatedRawStr {
  23                 n_start_hashes: 0,
  24                 n_end_hashes: 0,
  25                 valid_start: true,
  26                 valid_end: true,
  27                 possible_terminator_offset: None,
  28             },
  29             Ok(ValidatedRawStr { n_hashes: 0 }),
  30         );
  31     }
  32
  33     #[test]
  34     fn test_raw_no_start() {
  35         check_raw_str(
  36             r##""abc"#"##,
  37             UnvalidatedRawStr {
  38                 n_start_hashes: 0,
  39                 n_end_hashes: 0,
  40                 valid_start: true,
  41                 valid_end: true,
  42                 possible_terminator_offset: None,
  43             },
  44             Ok(ValidatedRawStr { n_hashes: 0 }),
  45         );
  46     }
  47
  48     #[test]
  49     fn test_too_many_terminators() {
  50         // this error is handled in the parser later
  51         check_raw_str(
  52             r###"#"abc"##"###,
  53             UnvalidatedRawStr {
  54                 n_start_hashes: 1,
  55                 n_end_hashes: 1,
  56                 valid_end: true,
  57                 valid_start: true,
  58                 possible_terminator_offset: None,
  59             },
  60             Ok(ValidatedRawStr { n_hashes: 1 }),
  61         );
  62     }
  63
  64     #[test]
  65     fn test_unterminated() {
  66         check_raw_str(
  67             r#"#"abc"#,
  68             UnvalidatedRawStr {
  69                 n_start_hashes: 1,
  70                 n_end_hashes: 0,
  71                 valid_end: false,
  72                 valid_start: true,
  73                 possible_terminator_offset: None,
  74             },
  75             Err(LexRawStrError::NoTerminator {
  76                 expected: 1,
  77                 found: 0,
  78                 possible_terminator_offset: None,
  79             }),
  80         );
  81         check_raw_str(
  82             r###"##"abc"#"###,
  83             UnvalidatedRawStr {
  84                 n_start_hashes: 2,
  85                 n_end_hashes: 1,
  86                 valid_start: true,
  87                 valid_end: false,
  88                 possible_terminator_offset: Some(7),
  89             },
  90             Err(LexRawStrError::NoTerminator {
  91                 expected: 2,
  92                 found: 1,
  93                 possible_terminator_offset: Some(7),
  94             }),
  95         );
  96         // We're looking for "# not just any #
  97         check_raw_str(
  98             r###"##"abc#"###,
  99             UnvalidatedRawStr {
 100                 n_start_hashes: 2,
 101                 n_end_hashes: 0,
 102                 valid_start: true,
 103                 valid_end: false,
 104                 possible_terminator_offset: None,
 105             },
 106             Err(LexRawStrError::NoTerminator {
 107                 expected: 2,
 108                 found: 0,
 109                 possible_terminator_offset: None,
 110             }),
 111         )
 112     }
 113
 114     #[test]
 115     fn test_invalid_start() {
 116         check_raw_str(
 117             r##"#~"abc"#"##,
 118             UnvalidatedRawStr {
 119                 n_start_hashes: 1,
 120                 n_end_hashes: 0,
 121                 valid_start: false,
 122                 valid_end: false,
 123                 possible_terminator_offset: None,
 124             },
 125             Err(LexRawStrError::InvalidStarter),
 126         );
 127     }
 128
 129     #[test]
 130     fn test_unterminated_no_pound() {
 131         // https://github.com/rust-lang/rust/issues/70677
 132         check_raw_str(
 133             r#"""#,
 134             UnvalidatedRawStr {
 135                 n_start_hashes: 0,
 136                 n_end_hashes: 0,
 137                 valid_start: true,
 138                 valid_end: false,
 139                 possible_terminator_offset: None,
 140             },
 141             Err(LexRawStrError::NoTerminator {
 142                 expected: 0,
 143                 found: 0,
 144                 possible_terminator_offset: None,
 145             }),
 146         );
 147     }
 148 }