src/librustc_lexer/src/tests.rs

   1 use super::*;
   2
   3 use expect_test::{expect, Expect};
   4
   5 fn check_raw_str(s: &str, expected_hashes: u16, expected_err: Option<RawStrError>) {
   6     let s = &format!("r{}", s);
   7     let mut cursor = Cursor::new(s);
   8     cursor.bump();
   9     let (n_hashes, err) = cursor.raw_double_quoted_string(0);
  10     assert_eq!(n_hashes, expected_hashes);
  11     assert_eq!(err, expected_err);
  12 }
  13
  14 #[test]
  15 fn test_naked_raw_str() {
  16     check_raw_str(r#""abc""#, 0, None);
  17 }
  18
  19 #[test]
  20 fn test_raw_no_start() {
  21     check_raw_str(r##""abc"#"##, 0, None);
  22 }
  23
  24 #[test]
  25 fn test_too_many_terminators() {
  26     // this error is handled in the parser later
  27     check_raw_str(r###"#"abc"##"###, 1, None);
  28 }
  29
  30 #[test]
  31 fn test_unterminated() {
  32     check_raw_str(
  33         r#"#"abc"#,
  34         1,
  35         Some(RawStrError::NoTerminator { expected: 1, found: 0, possible_terminator_offset: None }),
  36     );
  37     check_raw_str(
  38         r###"##"abc"#"###,
  39         2,
  40         Some(RawStrError::NoTerminator {
  41             expected: 2,
  42             found: 1,
  43             possible_terminator_offset: Some(7),
  44         }),
  45     );
  46     // We're looking for "# not just any #
  47     check_raw_str(
  48         r###"##"abc#"###,
  49         2,
  50         Some(RawStrError::NoTerminator { expected: 2, found: 0, possible_terminator_offset: None }),
  51     )
  52 }
  53
  54 #[test]
  55 fn test_invalid_start() {
  56     check_raw_str(r##"#~"abc"#"##, 1, Some(RawStrError::InvalidStarter { bad_char: '~' }));
  57 }
  58
  59 #[test]
  60 fn test_unterminated_no_pound() {
  61     // https://github.com/rust-lang/rust/issues/70677
  62     check_raw_str(
  63         r#"""#,
  64         0,
  65         Some(RawStrError::NoTerminator { expected: 0, found: 0, possible_terminator_offset: None }),
  66     );
  67 }
  68
  69 #[test]
  70 fn test_valid_shebang() {
  71     // https://github.com/rust-lang/rust/issues/70528
  72     let input = "#!/usr/bin/rustrun\nlet x = 5;";
  73     assert_eq!(strip_shebang(input), Some(18));
  74 }
  75
  76 #[test]
  77 fn test_invalid_shebang_valid_rust_syntax() {
  78     // https://github.com/rust-lang/rust/issues/70528
  79     let input = "#!    [bad_attribute]";
  80     assert_eq!(strip_shebang(input), None);
  81 }
  82
  83 #[test]
  84 fn test_shebang_second_line() {
  85     // Because shebangs are interpreted by the kernel, they must be on the first line
  86     let input = "\n#!/bin/bash";
  87     assert_eq!(strip_shebang(input), None);
  88 }
  89
  90 #[test]
  91 fn test_shebang_space() {
  92     let input = "#!    /bin/bash";
  93     assert_eq!(strip_shebang(input), Some(input.len()));
  94 }
  95
  96 #[test]
  97 fn test_shebang_empty_shebang() {
  98     let input = "#!    \n[attribute(foo)]";
  99     assert_eq!(strip_shebang(input), None);
 100 }
 101
 102 #[test]
 103 fn test_invalid_shebang_comment() {
 104     let input = "#!//bin/ami/a/comment\n[";
 105     assert_eq!(strip_shebang(input), None)
 106 }
 107
 108 #[test]
 109 fn test_invalid_shebang_another_comment() {
 110     let input = "#!/*bin/ami/a/comment*/\n[attribute";
 111     assert_eq!(strip_shebang(input), None)
 112 }
 113
 114 #[test]
 115 fn test_shebang_valid_rust_after() {
 116     let input = "#!/*bin/ami/a/comment*/\npub fn main() {}";
 117     assert_eq!(strip_shebang(input), Some(23))
 118 }
 119
 120 #[test]
 121 fn test_shebang_followed_by_attrib() {
 122     let input = "#!/bin/rust-scripts\n#![allow_unused(true)]";
 123     assert_eq!(strip_shebang(input), Some(19));
 124 }
 125
 126 fn check_lexing(src: &str, expect: Expect) {
 127     let actual: String = tokenize(src).map(|token| format!("{:?}\n", token)).collect();
 128     expect.assert_eq(&actual)
 129 }
 130
 131 #[test]
 132 fn comment_flavors() {
 133     check_lexing(
 134         r"
 135 // line
 136 //// line as well
 137 /// outer doc line
 138 //! inner doc line
 139 /* block */
 140 /**/
 141 /*** also block */
 142 /** outer doc block */
 143 /*! inner doc block */
 144 ",
 145         expect![[r#"
 146                 Token { kind: Whitespace, len: 1 }
 147                 Token { kind: LineComment { doc_style: None }, len: 7 }
 148                 Token { kind: Whitespace, len: 1 }
 149                 Token { kind: LineComment { doc_style: None }, len: 17 }
 150                 Token { kind: Whitespace, len: 1 }
 151                 Token { kind: LineComment { doc_style: Some(Outer) }, len: 18 }
 152                 Token { kind: Whitespace, len: 1 }
 153                 Token { kind: LineComment { doc_style: Some(Inner) }, len: 18 }
 154                 Token { kind: Whitespace, len: 1 }
 155                 Token { kind: BlockComment { doc_style: None, terminated: true }, len: 11 }
 156                 Token { kind: Whitespace, len: 1 }
 157                 Token { kind: BlockComment { doc_style: None, terminated: true }, len: 4 }
 158                 Token { kind: Whitespace, len: 1 }
 159                 Token { kind: BlockComment { doc_style: None, terminated: true }, len: 18 }
 160                 Token { kind: Whitespace, len: 1 }
 161                 Token { kind: BlockComment { doc_style: Some(Outer), terminated: true }, len: 22 }
 162                 Token { kind: Whitespace, len: 1 }
 163                 Token { kind: BlockComment { doc_style: Some(Inner), terminated: true }, len: 22 }
 164                 Token { kind: Whitespace, len: 1 }
 165             "#]],
 166     )
 167 }