ui_test/src/lib.rs

   1 #![allow(clippy::enum_variant_names, clippy::useless_format, clippy::too_many_arguments)]
   2
   3 use std::collections::VecDeque;
   4 use std::fmt::Write;
   5 use std::path::{Path, PathBuf};
   6 use std::process::{Command, ExitStatus};
   7 use std::sync::atomic::{AtomicUsize, Ordering};
   8 use std::sync::Mutex;
   9
  10 pub use color_eyre;
  11 use color_eyre::eyre::Result;
  12 use colored::*;
  13 use comments::ErrorMatch;
  14 use regex::Regex;
  15 use rustc_stderr::{Level, Message};
  16
  17 use crate::comments::{Comments, Condition};
  18
  19 mod comments;
  20 mod rustc_stderr;
  21 #[cfg(test)]
  22 mod tests;
  23
  24 #[derive(Debug)]
  25 pub struct Config {
  26     /// Arguments passed to the binary that is executed.
  27     pub args: Vec<String>,
  28     /// `None` to run on the host, otherwise a target triple
  29     pub target: Option<String>,
  30     /// Filters applied to stderr output before processing it
  31     pub stderr_filters: Filter,
  32     /// Filters applied to stdout output before processing it
  33     pub stdout_filters: Filter,
  34     /// The folder in which to start searching for .rs files
  35     pub root_dir: PathBuf,
  36     pub mode: Mode,
  37     pub program: PathBuf,
  38     pub output_conflict_handling: OutputConflictHandling,
  39     /// Only run tests with one of these strings in their path/name
  40     pub path_filter: Vec<String>,
  41 }
  42
  43 #[derive(Debug)]
  44 pub enum OutputConflictHandling {
  45     /// The default: emit a diff of the expected/actual output.
  46     Error,
  47     /// Ignore mismatches in the stderr/stdout files.
  48     Ignore,
  49     /// Instead of erroring if the stderr/stdout differs from the expected
  50     /// automatically replace it with the found output (after applying filters).
  51     Bless,
  52 }
  53
  54 pub type Filter = Vec<(Regex, &'static str)>;
  55
  56 pub fn run_tests(config: Config) -> Result<()> {
  57     eprintln!("   Compiler flags: {:?}", config.args);
  58
  59     // Get the triple with which to run the tests
  60     let target = config.target.clone().unwrap_or_else(|| config.get_host());
  61
  62     // A channel for files to process
  63     let (submit, receive) = crossbeam::channel::unbounded();
  64
  65     // Some statistics and failure reports.
  66     let failures = Mutex::new(vec![]);
  67     let succeeded = AtomicUsize::default();
  68     let ignored = AtomicUsize::default();
  69     let filtered = AtomicUsize::default();
  70
  71     crossbeam::scope(|s| -> Result<()> {
  72         // Create a thread that is in charge of walking the directory and submitting jobs.
  73         // It closes the channel when it is done.
  74         s.spawn(|_| {
  75             let mut todo = VecDeque::new();
  76             todo.push_back(config.root_dir.clone());
  77             while let Some(path) = todo.pop_front() {
  78                 if path.is_dir() {
  79                     // Enqueue everything inside this directory.
  80                     // We want it sorted, to have some control over scheduling of slow tests.
  81                     let mut entries =
  82                         std::fs::read_dir(path).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
  83                     entries.sort_by_key(|e| e.file_name());
  84                     for entry in entries {
  85                         todo.push_back(entry.path());
  86                     }
  87                 } else if path.extension().map(|ext| ext == "rs").unwrap_or(false) {
  88                     // Forward .rs files to the test workers.
  89                     submit.send(path).unwrap();
  90                 }
  91             }
  92             // There will be no more jobs. This signals the workers to quit.
  93             // (This also ensures `submit` is moved into this closure.)
  94             drop(submit);
  95         });
  96
  97         let mut threads = vec![];
  98
  99         // Create N worker threads that receive files to test.
 100         for _ in 0..std::thread::available_parallelism().unwrap().get() {
 101             threads.push(s.spawn(|_| -> Result<()> {
 102                 for path in &receive {
 103                     if !config.path_filter.is_empty() {
 104                         let path_display = path.display().to_string();
 105                         if !config.path_filter.iter().any(|filter| path_display.contains(filter)) {
 106                             filtered.fetch_add(1, Ordering::Relaxed);
 107                             continue;
 108                         }
 109                     }
 110                     let comments = Comments::parse_file(&path)?;
 111                     // Ignore file if only/ignore rules do (not) apply
 112                     if !test_file_conditions(&comments, &target) {
 113                         ignored.fetch_add(1, Ordering::Relaxed);
 114                         eprintln!(
 115                             "{} ... {}",
 116                             path.display(),
 117                             "ignored (in-test comment)".yellow()
 118                         );
 119                         continue;
 120                     }
 121                     // Run the test for all revisions
 122                     for revision in
 123                         comments.revisions.clone().unwrap_or_else(|| vec![String::new()])
 124                     {
 125                         let (m, errors, stderr) =
 126                             run_test(&path, &config, &target, &revision, &comments);
 127
 128                         // Using a single `eprintln!` to prevent messages from threads from getting intermingled.
 129                         let mut msg = format!("{} ", path.display());
 130                         if !revision.is_empty() {
 131                             write!(msg, "(revision `{revision}`) ").unwrap();
 132                         }
 133                         write!(msg, "... ").unwrap();
 134                         if errors.is_empty() {
 135                             eprintln!("{msg}{}", "ok".green());
 136                             succeeded.fetch_add(1, Ordering::Relaxed);
 137                         } else {
 138                             eprintln!("{msg}{}", "FAILED".red().bold());
 139                             failures.lock().unwrap().push((
 140                                 path.clone(),
 141                                 m,
 142                                 revision,
 143                                 errors,
 144                                 stderr,
 145                             ));
 146                         }
 147                     }
 148                 }
 149                 Ok(())
 150             }));
 151         }
 152         for thread in threads {
 153             thread.join().unwrap()?;
 154         }
 155         Ok(())
 156     })
 157     .unwrap()?;
 158
 159     // Print all errors in a single thread to show reliable output
 160     let failures = failures.into_inner().unwrap();
 161     let succeeded = succeeded.load(Ordering::Relaxed);
 162     let ignored = ignored.load(Ordering::Relaxed);
 163     let filtered = filtered.load(Ordering::Relaxed);
 164     if !failures.is_empty() {
 165         for (path, miri, revision, errors, stderr) in &failures {
 166             eprintln!();
 167             eprint!("{}", path.display().to_string().underline());
 168             if !revision.is_empty() {
 169                 eprint!(" (revision `{}`)", revision);
 170             }
 171             eprint!(" {}", "FAILED".red());
 172             eprintln!();
 173             eprintln!("command: {:?}", miri);
 174             eprintln!();
 175             let mut dump_stderr = true;
 176             for error in errors {
 177                 match error {
 178                     Error::ExitStatus(mode, exit_status) => eprintln!("{mode:?} got {exit_status}"),
 179                     Error::PatternNotFound { pattern, definition_line } => {
 180                         eprintln!("`{pattern}` {} in stderr output", "not found".red());
 181                         eprintln!(
 182                             "expected because of pattern here: {}:{definition_line}",
 183                             path.display().to_string().bold()
 184                         );
 185                     }
 186                     Error::NoPatternsFound => {
 187                         eprintln!("{}", "no error patterns found in failure test".red());
 188                     }
 189                     Error::PatternFoundInPassTest =>
 190                         eprintln!("{}", "error pattern found in success test".red()),
 191                     Error::OutputDiffers { path, actual, expected } => {
 192                         if path.extension().unwrap() == "stderr" {
 193                             dump_stderr = false;
 194                         }
 195                         eprintln!("actual output differed from expected {}", path.display());
 196                         eprintln!("{}", pretty_assertions::StrComparison::new(expected, actual));
 197                         eprintln!()
 198                     }
 199                     Error::ErrorsWithoutPattern { path: None, msgs } => {
 200                         eprintln!(
 201                             "There were {} unmatched diagnostics that occurred outside the testfile and had not pattern",
 202                             msgs.len(),
 203                         );
 204                         for Message { level, message } in msgs {
 205                             eprintln!("    {level:?}: {message}")
 206                         }
 207                     }
 208                     Error::ErrorsWithoutPattern { path: Some((path, line)), msgs } => {
 209                         eprintln!(
 210                             "There were {} unmatched diagnostics at {}:{line}",
 211                             msgs.len(),
 212                             path.display()
 213                         );
 214                         for Message { level, message } in msgs {
 215                             eprintln!("    {level:?}: {message}")
 216                         }
 217                     }
 218                     Error::ErrorPatternWithoutErrorAnnotation(path, line) => {
 219                         eprintln!(
 220                             "Annotation at {}:{line} matched an error diagnostic but did not have `ERROR` before its message",
 221                             path.display()
 222                         );
 223                     }
 224                 }
 225                 eprintln!();
 226             }
 227             // Unless we already dumped the stderr via an OutputDiffers diff, let's dump it here.
 228             if dump_stderr {
 229                 eprintln!("actual stderr:");
 230                 eprintln!("{}", stderr);
 231                 eprintln!();
 232             }
 233         }
 234         eprintln!("{}", "failures:".red().underline());
 235         for (path, _miri, _revision, _errors, _stderr) in &failures {
 236             eprintln!("    {}", path.display());
 237         }
 238         eprintln!();
 239         eprintln!(
 240             "test result: {}. {} tests failed, {} tests passed, {} ignored, {} filtered out",
 241             "FAIL".red(),
 242             failures.len().to_string().red().bold(),
 243             succeeded.to_string().green(),
 244             ignored.to_string().yellow(),
 245             filtered.to_string().yellow(),
 246         );
 247         std::process::exit(1);
 248     }
 249     eprintln!();
 250     eprintln!(
 251         "test result: {}. {} tests passed, {} ignored, {} filtered out",
 252         "ok".green(),
 253         succeeded.to_string().green(),
 254         ignored.to_string().yellow(),
 255         filtered.to_string().yellow(),
 256     );
 257     eprintln!();
 258     Ok(())
 259 }
 260
 261 #[derive(Debug)]
 262 enum Error {
 263     /// Got an invalid exit status for the given mode.
 264     ExitStatus(Mode, ExitStatus),
 265     PatternNotFound {
 266         pattern: String,
 267         definition_line: usize,
 268     },
 269     /// A ui test checking for failure does not have any failure patterns
 270     NoPatternsFound,
 271     /// A ui test checking for success has failure patterns
 272     PatternFoundInPassTest,
 273     /// Stderr/Stdout differed from the `.stderr`/`.stdout` file present.
 274     OutputDiffers {
 275         path: PathBuf,
 276         actual: String,
 277         expected: String,
 278     },
 279     ErrorsWithoutPattern {
 280         msgs: Vec<Message>,
 281         path: Option<(PathBuf, usize)>,
 282     },
 283     ErrorPatternWithoutErrorAnnotation(PathBuf, usize),
 284 }
 285
 286 type Errors = Vec<Error>;
 287
 288 fn run_test(
 289     path: &Path,
 290     config: &Config,
 291     target: &str,
 292     revision: &str,
 293     comments: &Comments,
 294 ) -> (Command, Errors, String) {
 295     // Run miri
 296     let mut miri = Command::new(&config.program);
 297     miri.args(config.args.iter());
 298     miri.arg(path);
 299     if !revision.is_empty() {
 300         miri.arg(format!("--cfg={revision}"));
 301     }
 302     miri.arg("--error-format=json");
 303     for arg in &comments.compile_flags {
 304         miri.arg(arg);
 305     }
 306     for (k, v) in &comments.env_vars {
 307         miri.env(k, v);
 308     }
 309     let output = miri.output().expect("could not execute miri");
 310     let mut errors = config.mode.ok(output.status);
 311     let stderr = check_test_result(
 312         path,
 313         config,
 314         target,
 315         revision,
 316         comments,
 317         &mut errors,
 318         &output.stdout,
 319         &output.stderr,
 320     );
 321     (miri, errors, stderr)
 322 }
 323
 324 fn check_test_result(
 325     path: &Path,
 326     config: &Config,
 327     target: &str,
 328     revision: &str,
 329     comments: &Comments,
 330     errors: &mut Errors,
 331     stdout: &[u8],
 332     stderr: &[u8],
 333 ) -> String {
 334     // Always remove annotation comments from stderr.
 335     let diagnostics = rustc_stderr::process(path, stderr);
 336     let stdout = std::str::from_utf8(stdout).unwrap();
 337     // Check output files (if any)
 338     let revised = |extension: &str| {
 339         if revision.is_empty() {
 340             extension.to_string()
 341         } else {
 342             format!("{}.{}", revision, extension)
 343         }
 344     };
 345     // Check output files against actual output
 346     check_output(
 347         &diagnostics.rendered,
 348         path,
 349         errors,
 350         revised("stderr"),
 351         target,
 352         &config.stderr_filters,
 353         config,
 354         comments,
 355     );
 356     check_output(
 357         stdout,
 358         path,
 359         errors,
 360         revised("stdout"),
 361         target,
 362         &config.stdout_filters,
 363         config,
 364         comments,
 365     );
 366     // Check error annotations in the source against output
 367     check_annotations(
 368         diagnostics.messages,
 369         diagnostics.messages_from_unknown_file_or_line,
 370         path,
 371         errors,
 372         config,
 373         revision,
 374         comments,
 375     );
 376     diagnostics.rendered
 377 }
 378
 379 fn check_annotations(
 380     mut messages: Vec<Vec<Message>>,
 381     mut messages_from_unknown_file_or_line: Vec<Message>,
 382     path: &Path,
 383     errors: &mut Errors,
 384     config: &Config,
 385     revision: &str,
 386     comments: &Comments,
 387 ) {
 388     if let Some((ref error_pattern, definition_line)) = comments.error_pattern {
 389         // first check the diagnostics messages outside of our file. We check this first, so that
 390         // you can mix in-file annotations with //@error-pattern annotations, even if there is overlap
 391         // in the messages.
 392         if let Some(i) = messages_from_unknown_file_or_line
 393             .iter()
 394             .position(|msg| msg.message.contains(error_pattern))
 395         {
 396             messages_from_unknown_file_or_line.remove(i);
 397         } else {
 398             errors.push(Error::PatternNotFound {
 399                 pattern: error_pattern.to_string(),
 400                 definition_line,
 401             });
 402         }
 403     }
 404
 405     // The order on `Level` is such that `Error` is the highest level.
 406     // We will ensure that *all* diagnostics of level at least `lowest_annotation_level`
 407     // are matched.
 408     let mut lowest_annotation_level = Level::Error;
 409     for &ErrorMatch { ref matched, revision: ref rev, definition_line, line, level } in
 410         &comments.error_matches
 411     {
 412         if let Some(rev) = rev {
 413             if rev != revision {
 414                 continue;
 415             }
 416         }
 417         if let Some(level) = level {
 418             // If we found a diagnostic with a level annotation, make sure that all
 419             // diagnostics of that level have annotations, even if we don't end up finding a matching diagnostic
 420             // for this pattern.
 421             lowest_annotation_level = std::cmp::min(lowest_annotation_level, level);
 422         }
 423
 424         if let Some(msgs) = messages.get_mut(line) {
 425             let found = msgs.iter().position(|msg| {
 426                 msg.message.contains(matched)
 427                     // in case there is no level on the annotation, match any level.
 428                     && level.map_or(true, |level| {
 429                         msg.level == level
 430                     })
 431             });
 432             if let Some(found) = found {
 433                 let msg = msgs.remove(found);
 434                 if msg.level == Level::Error && level.is_none() {
 435                     errors
 436                         .push(Error::ErrorPatternWithoutErrorAnnotation(path.to_path_buf(), line));
 437                 }
 438                 continue;
 439             }
 440         }
 441
 442         errors.push(Error::PatternNotFound { pattern: matched.to_string(), definition_line });
 443     }
 444
 445     let filter = |msgs: Vec<Message>| -> Vec<_> {
 446         msgs.into_iter().filter(|msg| msg.level >= lowest_annotation_level).collect()
 447     };
 448
 449     let messages_from_unknown_file_or_line = filter(messages_from_unknown_file_or_line);
 450     if !messages_from_unknown_file_or_line.is_empty() {
 451         errors.push(Error::ErrorsWithoutPattern {
 452             path: None,
 453             msgs: messages_from_unknown_file_or_line,
 454         });
 455     }
 456
 457     for (line, msgs) in messages.into_iter().enumerate() {
 458         let msgs = filter(msgs);
 459         if !msgs.is_empty() {
 460             errors
 461                 .push(Error::ErrorsWithoutPattern { path: Some((path.to_path_buf(), line)), msgs });
 462         }
 463     }
 464
 465     match (config.mode, comments.error_pattern.is_some() || !comments.error_matches.is_empty()) {
 466         (Mode::Pass, true) | (Mode::Panic, true) => errors.push(Error::PatternFoundInPassTest),
 467         (Mode::Fail, false) => errors.push(Error::NoPatternsFound),
 468         _ => {}
 469     }
 470 }
 471
 472 fn check_output(
 473     output: &str,
 474     path: &Path,
 475     errors: &mut Errors,
 476     kind: String,
 477     target: &str,
 478     filters: &Filter,
 479     config: &Config,
 480     comments: &Comments,
 481 ) {
 482     let output = normalize(path, output, filters, comments);
 483     let path = output_path(path, comments, kind, target);
 484     match config.output_conflict_handling {
 485         OutputConflictHandling::Bless =>
 486             if output.is_empty() {
 487                 let _ = std::fs::remove_file(path);
 488             } else {
 489                 std::fs::write(path, &output).unwrap();
 490             },
 491         OutputConflictHandling::Error => {
 492             let expected_output = std::fs::read_to_string(&path).unwrap_or_default();
 493             if output != expected_output {
 494                 errors.push(Error::OutputDiffers {
 495                     path,
 496                     actual: output,
 497                     expected: expected_output,
 498                 });
 499             }
 500         }
 501         OutputConflictHandling::Ignore => {}
 502     }
 503 }
 504
 505 fn output_path(path: &Path, comments: &Comments, kind: String, target: &str) -> PathBuf {
 506     if comments.stderr_per_bitwidth {
 507         return path.with_extension(format!("{}bit.{kind}", get_pointer_width(target)));
 508     }
 509     path.with_extension(kind)
 510 }
 511
 512 fn test_condition(condition: &Condition, target: &str) -> bool {
 513     match condition {
 514         Condition::Bitwidth(bits) => get_pointer_width(target) == *bits,
 515         Condition::Target(t) => target.contains(t),
 516     }
 517 }
 518
 519 /// Returns whether according to the in-file conditions, this file should be run.
 520 fn test_file_conditions(comments: &Comments, target: &str) -> bool {
 521     if comments.ignore.iter().any(|c| test_condition(c, target)) {
 522         return false;
 523     }
 524     comments.only.iter().all(|c| test_condition(c, target))
 525 }
 526
 527 // Taken 1:1 from compiletest-rs
 528 fn get_pointer_width(triple: &str) -> u8 {
 529     if (triple.contains("64") && !triple.ends_with("gnux32") && !triple.ends_with("gnu_ilp32"))
 530         || triple.starts_with("s390x")
 531     {
 532         64
 533     } else if triple.starts_with("avr") {
 534         16
 535     } else {
 536         32
 537     }
 538 }
 539
 540 fn normalize(path: &Path, text: &str, filters: &Filter, comments: &Comments) -> String {
 541     // Useless paths
 542     let mut text = text.replace(&path.parent().unwrap().display().to_string(), "$DIR");
 543     if let Some(lib_path) = option_env!("RUSTC_LIB_PATH") {
 544         text = text.replace(lib_path, "RUSTLIB");
 545     }
 546
 547     for (regex, replacement) in filters.iter() {
 548         text = regex.replace_all(&text, *replacement).to_string();
 549     }
 550
 551     for (from, to) in &comments.normalize_stderr {
 552         text = from.replace_all(&text, to).to_string();
 553     }
 554     text
 555 }
 556
 557 impl Config {
 558     fn get_host(&self) -> String {
 559         rustc_version::VersionMeta::for_command(std::process::Command::new(&self.program))
 560             .expect("failed to parse rustc version info")
 561             .host
 562     }
 563 }
 564
 565 #[derive(Copy, Clone, Debug)]
 566 pub enum Mode {
 567     // The test passes a full execution of the rustc driver
 568     Pass,
 569     // The rustc driver panicked
 570     Panic,
 571     // The rustc driver emitted an error
 572     Fail,
 573 }
 574
 575 impl Mode {
 576     fn ok(self, status: ExitStatus) -> Errors {
 577         match (status.code().unwrap(), self) {
 578             (1, Mode::Fail) | (101, Mode::Panic) | (0, Mode::Pass) => vec![],
 579             _ => vec![Error::ExitStatus(self, status)],
 580         }
 581     }
 582 }