vendor/ui_test-0.20.0/src/tests.rs

   1 use std::path::{Path, PathBuf};
   2
   3 use crate::rustc_stderr::Level;
   4 use crate::rustc_stderr::Message;
   5
   6 use super::*;
   7
   8 fn config() -> Config {
   9     Config {
  10         root_dir: PathBuf::from("$RUSTROOT"),
  11         program: CommandBuilder::cmd("cake"),
  12         ..Config::rustc(PathBuf::new())
  13     }
  14 }
  15
  16 #[test]
  17 fn issue_2156() {
  18     let s = r"
  19 use std::mem;
  20
  21 fn main() {
  22     let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ ERROR: encountered a dangling reference (address $HEX is unallocated)
  23 }
  24     ";
  25     let comments = Comments::parse(s).unwrap();
  26     let mut errors = vec![];
  27     let config = config();
  28     let messages = vec![
  29         vec![], vec![], vec![], vec![], vec![],
  30         vec![
  31             Message {
  32                 message:"Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
  33                 level: Level::Error,
  34                 line_col: None,
  35             }
  36         ]
  37     ];
  38     check_annotations(
  39         messages,
  40         vec![],
  41         Path::new("moobar"),
  42         &mut errors,
  43         &config,
  44         "",
  45         &comments,
  46     )
  47     .unwrap();
  48     match &errors[..] {
  49         [Error::PatternNotFound(pattern), Error::ErrorsWithoutPattern { path, .. }]
  50             if path.as_ref().is_some_and(|p| p.line().get() == 5) && pattern.line().get() == 5 => {}
  51         _ => panic!("{:#?}", errors),
  52     }
  53 }
  54
  55 #[test]
  56 fn find_pattern() {
  57     let s = r"
  58 use std::mem;
  59
  60 fn main() {
  61     let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ ERROR: encountered a dangling reference (address 0x10 is unallocated)
  62 }
  63     ";
  64     let comments = Comments::parse(s).unwrap();
  65     let config = config();
  66     {
  67         let messages = vec![vec![], vec![], vec![], vec![], vec![], vec![
  68                 Message {
  69                     message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
  70                     level: Level::Error,
  71                     line_col: None,
  72                 }
  73             ]
  74         ];
  75         let mut errors = vec![];
  76         check_annotations(
  77             messages,
  78             vec![],
  79             Path::new("moobar"),
  80             &mut errors,
  81             &config,
  82             "",
  83             &comments,
  84         )
  85         .unwrap();
  86         match &errors[..] {
  87             [] => {}
  88             _ => panic!("{:#?}", errors),
  89         }
  90     }
  91
  92     // only difference to above is a wrong line number
  93     {
  94         let messages = vec![vec![], vec![], vec![], vec![], vec![
  95                 Message {
  96                     message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
  97                     level: Level::Error,
  98                     line_col: None,
  99                 }
 100             ]
 101         ];
 102         let mut errors = vec![];
 103         check_annotations(
 104             messages,
 105             vec![],
 106             Path::new("moobar"),
 107             &mut errors,
 108             &config,
 109             "",
 110             &comments,
 111         )
 112         .unwrap();
 113         match &errors[..] {
 114             [Error::PatternNotFound(pattern), Error::ErrorsWithoutPattern { path, .. }]
 115                 if path.as_ref().is_some_and(|p| p.line().get() == 4)
 116                     && pattern.line().get() == 5 => {}
 117             _ => panic!("not the expected error: {:#?}", errors),
 118         }
 119     }
 120
 121     // only difference to first is a wrong level
 122     {
 123         let messages = vec![
 124             vec![], vec![], vec![], vec![], vec![],
 125             vec![
 126                 Message {
 127                     message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
 128                     level: Level::Note,
 129                     line_col: None,
 130                 }
 131             ]
 132         ];
 133         let mut errors = vec![];
 134         check_annotations(
 135             messages,
 136             vec![],
 137             Path::new("moobar"),
 138             &mut errors,
 139             &config,
 140             "",
 141             &comments,
 142         )
 143         .unwrap();
 144         match &errors[..] {
 145             // Note no `ErrorsWithoutPattern`, because there are no `//~NOTE` in the test file, so we ignore them
 146             [Error::PatternNotFound(pattern)] if pattern.line().get() == 5 => {}
 147             _ => panic!("not the expected error: {:#?}", errors),
 148         }
 149     }
 150 }
 151
 152 #[test]
 153 fn duplicate_pattern() {
 154     let s = r"
 155 use std::mem;
 156
 157 fn main() {
 158     let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ ERROR: encountered a dangling reference (address 0x10 is unallocated)
 159     //~^ ERROR: encountered a dangling reference (address 0x10 is unallocated)
 160 }
 161     ";
 162     let comments = Comments::parse(s).unwrap();
 163     let config = config();
 164     let messages = vec![
 165         vec![], vec![], vec![], vec![], vec![],
 166         vec![
 167             Message {
 168                 message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
 169                 level: Level::Error,
 170                 line_col: None,
 171             }
 172         ]
 173     ];
 174     let mut errors = vec![];
 175     check_annotations(
 176         messages,
 177         vec![],
 178         Path::new("moobar"),
 179         &mut errors,
 180         &config,
 181         "",
 182         &comments,
 183     )
 184     .unwrap();
 185     match &errors[..] {
 186         [Error::PatternNotFound(pattern)] if pattern.line().get() == 6 => {}
 187         _ => panic!("{:#?}", errors),
 188     }
 189 }
 190
 191 #[test]
 192 fn missing_pattern() {
 193     let s = r"
 194 use std::mem;
 195
 196 fn main() {
 197     let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ ERROR: encountered a dangling reference (address 0x10 is unallocated)
 198 }
 199     ";
 200     let comments = Comments::parse(s).unwrap();
 201     let config = config();
 202     let messages = vec![
 203         vec![], vec![], vec![], vec![], vec![],
 204         vec![
 205             Message {
 206                 message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
 207                 level: Level::Error,
 208                 line_col: None,
 209             },
 210             Message {
 211                 message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
 212                 level: Level::Error,
 213                 line_col: None,
 214             }
 215         ]
 216     ];
 217     let mut errors = vec![];
 218     check_annotations(
 219         messages,
 220         vec![],
 221         Path::new("moobar"),
 222         &mut errors,
 223         &config,
 224         "",
 225         &comments,
 226     )
 227     .unwrap();
 228     match &errors[..] {
 229         [Error::ErrorsWithoutPattern { path, .. }]
 230             if path.as_ref().is_some_and(|p| p.line().get() == 5) => {}
 231         _ => panic!("{:#?}", errors),
 232     }
 233 }
 234
 235 #[test]
 236 fn missing_warn_pattern() {
 237     let s = r"
 238 use std::mem;
 239
 240 fn main() {
 241     let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ ERROR: encountered a dangling reference (address 0x10 is unallocated)
 242     //~^ WARN: cake
 243 }
 244     ";
 245     let comments = Comments::parse(s).unwrap();
 246     let config = config();
 247     let messages= vec![
 248         vec![],
 249         vec![],
 250         vec![],
 251         vec![],
 252         vec![],
 253         vec![
 254             Message {
 255                 message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
 256                 level: Level::Error,
 257                 line_col: None,
 258             },
 259             Message {
 260                 message: "kaboom".to_string(),
 261                 level: Level::Warn,
 262                 line_col: None,
 263             },
 264             Message {
 265                 message: "cake".to_string(),
 266                 level: Level::Warn,
 267                 line_col: None,
 268             },
 269         ],
 270     ];
 271     let mut errors = vec![];
 272     check_annotations(
 273         messages,
 274         vec![],
 275         Path::new("moobar"),
 276         &mut errors,
 277         &config,
 278         "",
 279         &comments,
 280     )
 281     .unwrap();
 282     match &errors[..] {
 283         [Error::ErrorsWithoutPattern { path, msgs, .. }]
 284             if path.as_ref().is_some_and(|p| p.line().get() == 5) =>
 285         {
 286             match &msgs[..] {
 287                 [Message {
 288                     message,
 289                     level: Level::Warn,
 290                     line_col: _,
 291                 }] if message == "kaboom" => {}
 292                 _ => panic!("{:#?}", msgs),
 293             }
 294         }
 295         _ => panic!("{:#?}", errors),
 296     }
 297 }
 298
 299 #[test]
 300 fn missing_implicit_warn_pattern() {
 301     let s = r"
 302 use std::mem;
 303 //@require-annotations-for-level: ERROR
 304 fn main() {
 305     let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ ERROR: encountered a dangling reference (address 0x10 is unallocated)
 306     //~^ WARN: cake
 307 }
 308     ";
 309     let comments = Comments::parse(s).unwrap();
 310     let config = config();
 311     let messages = vec![
 312         vec![],
 313         vec![],
 314         vec![],
 315         vec![],
 316         vec![],
 317         vec![
 318             Message {
 319                 message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
 320                 level: Level::Error,
 321                 line_col: None,
 322             },
 323             Message {
 324                 message: "kaboom".to_string(),
 325                 level: Level::Warn,
 326                 line_col: None,
 327             },
 328             Message {
 329                 message: "cake".to_string(),
 330                 level: Level::Warn,
 331                 line_col: None,
 332             },
 333         ],
 334     ];
 335     let mut errors = vec![];
 336     check_annotations(
 337         messages,
 338         vec![],
 339         Path::new("moobar"),
 340         &mut errors,
 341         &config,
 342         "",
 343         &comments,
 344     )
 345     .unwrap();
 346     match &errors[..] {
 347         [] => {}
 348         _ => panic!("{:#?}", errors),
 349     }
 350 }