tests/system.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 extern crate regex;
  12 extern crate rustfmt_nightly as rustfmt;
  13 extern crate term;
  14
  15 use std::collections::HashMap;
  16 use std::fs;
  17 use std::io::{self, BufRead, BufReader, Read};
  18 use std::path::{Path, PathBuf};
  19
  20 use rustfmt::*;
  21 use rustfmt::filemap::{write_system_newlines, FileMap};
  22 use rustfmt::config::{Config, ReportTactic};
  23 use rustfmt::rustfmt_diff::*;
  24
  25 const DIFF_CONTEXT_SIZE: usize = 3;
  26
  27 fn get_path_string(dir_entry: io::Result<fs::DirEntry>) -> String {
  28     let path = dir_entry.expect("Couldn't get DirEntry").path();
  29
  30     path.to_str().expect("Couldn't stringify path").to_owned()
  31 }
  32
  33 // Integration tests. The files in the tests/source are formatted and compared
  34 // to their equivalent in tests/target. The target file and config can be
  35 // overridden by annotations in the source file. The input and output must match
  36 // exactly.
  37 #[test]
  38 fn system_tests() {
  39     // Get all files in the tests/source directory.
  40     let files = fs::read_dir("tests/source").expect("Couldn't read source dir");
  41     // Turn a DirEntry into a String that represents the relative path to the
  42     // file.
  43     let files = files.map(get_path_string);
  44     let (_reports, count, fails) = check_files(files);
  45
  46     // Display results.
  47     println!("Ran {} system tests.", count);
  48     assert!(fails == 0, "{} system tests failed", fails);
  49 }
  50
  51 // Do the same for tests/coverage-source directory
  52 // the only difference is the coverage mode
  53 #[test]
  54 fn coverage_tests() {
  55     let files = fs::read_dir("tests/coverage/source").expect("Couldn't read source dir");
  56     let files = files.map(get_path_string);
  57     let (_reports, count, fails) = check_files(files);
  58
  59     println!("Ran {} tests in coverage mode.", count);
  60     assert!(fails == 0, "{} tests failed", fails);
  61 }
  62
  63 #[test]
  64 fn checkstyle_test() {
  65     let filename = "tests/writemode/source/fn-single-line.rs";
  66     let expected_filename = "tests/writemode/target/checkstyle.xml";
  67     assert_output(filename, expected_filename);
  68 }
  69
  70
  71 // Helper function for comparing the results of rustfmt
  72 // to a known output file generated by one of the write modes.
  73 fn assert_output(source: &str, expected_filename: &str) {
  74     let config = read_config(&source);
  75     let (file_map, _report) = format_file(source, &config);
  76
  77     // Populate output by writing to a vec.
  78     let mut out = vec![];
  79     let _ = filemap::write_all_files(&file_map, &mut out, &config);
  80     let output = String::from_utf8(out).unwrap();
  81
  82     let mut expected_file = fs::File::open(&expected_filename).expect("Couldn't open target");
  83     let mut expected_text = String::new();
  84     expected_file
  85         .read_to_string(&mut expected_text)
  86         .expect("Failed reading target");
  87
  88     let compare = make_diff(&expected_text, &output, DIFF_CONTEXT_SIZE);
  89     if compare.len() > 0 {
  90         let mut failures = HashMap::new();
  91         failures.insert(source.to_string(), compare);
  92         print_mismatches(failures);
  93         assert!(false, "Text does not match expected output");
  94     }
  95 }
  96
  97 // Idempotence tests. Files in tests/target are checked to be unaltered by
  98 // rustfmt.
  99 #[test]
 100 fn idempotence_tests() {
 101     // Get all files in the tests/target directory.
 102     let files = fs::read_dir("tests/target")
 103         .expect("Couldn't read target dir")
 104         .map(get_path_string);
 105     let (_reports, count, fails) = check_files(files);
 106
 107     // Display results.
 108     println!("Ran {} idempotent tests.", count);
 109     assert!(fails == 0, "{} idempotent tests failed", fails);
 110 }
 111
 112 // Run rustfmt on itself. This operation must be idempotent. We also check that
 113 // no warnings are emitted.
 114 #[test]
 115 fn self_tests() {
 116     let files = fs::read_dir("src/bin")
 117         .expect("Couldn't read src dir")
 118         .chain(fs::read_dir("tests").expect("Couldn't read tests dir"))
 119         .map(get_path_string);
 120     // Hack because there's no `IntoIterator` impl for `[T; N]`.
 121     let files = files.chain(Some("src/lib.rs".to_owned()).into_iter());
 122     let files = files.chain(Some("build.rs".to_owned()).into_iter());
 123
 124     let (reports, count, fails) = check_files(files);
 125     let mut warnings = 0;
 126
 127     // Display results.
 128     println!("Ran {} self tests.", count);
 129     assert!(fails == 0, "{} self tests failed", fails);
 130
 131     for format_report in reports {
 132         println!("{}", format_report);
 133         warnings += format_report.warning_count();
 134     }
 135
 136     assert!(
 137         warnings == 0,
 138         "Rustfmt's code generated {} warnings",
 139         warnings
 140     );
 141 }
 142
 143 #[test]
 144 fn stdin_formatting_smoke_test() {
 145     let input = Input::Text("fn main () {}".to_owned());
 146     let config = Config::default();
 147     let (error_summary, file_map, _report) =
 148         format_input::<io::Stdout>(input, &config, None).unwrap();
 149     assert!(error_summary.has_no_errors());
 150     for &(ref file_name, ref text) in &file_map {
 151         if file_name == "stdin" {
 152             assert!(text.to_string() == "fn main() {}\n");
 153             return;
 154         }
 155     }
 156     panic!("no stdin");
 157 }
 158
 159 #[test]
 160 fn format_lines_errors_are_reported() {
 161     let long_identifier = String::from_utf8(vec![b'a'; 239]).unwrap();
 162     let input = Input::Text(format!("fn {}() {{}}", long_identifier));
 163     let config = Config::default();
 164     let (error_summary, _file_map, _report) =
 165         format_input::<io::Stdout>(input, &config, None).unwrap();
 166     assert!(error_summary.has_formatting_errors());
 167 }
 168
 169 // For each file, run rustfmt and collect the output.
 170 // Returns the number of files checked and the number of failures.
 171 fn check_files<I>(files: I) -> (Vec<FormatReport>, u32, u32)
 172 where
 173     I: Iterator<Item = String>,
 174 {
 175     let mut count = 0;
 176     let mut fails = 0;
 177     let mut reports = vec![];
 178
 179     for file_name in files.filter(|f| f.ends_with(".rs")) {
 180         println!("Testing '{}'...", file_name);
 181
 182         match idempotent_check(file_name) {
 183             Ok(ref report) if report.has_warnings() => {
 184                 print!("{}", report);
 185                 fails += 1;
 186             }
 187             Ok(report) => reports.push(report),
 188             Err(msg) => {
 189                 print_mismatches(msg);
 190                 fails += 1;
 191             }
 192         }
 193
 194         count += 1;
 195     }
 196
 197     (reports, count, fails)
 198 }
 199
 200 fn print_mismatches(result: HashMap<String, Vec<Mismatch>>) {
 201     let mut t = term::stdout().unwrap();
 202
 203     for (file_name, diff) in result {
 204         print_diff(diff, |line_num| {
 205             format!("\nMismatch at {}:{}:", file_name, line_num)
 206         });
 207     }
 208
 209     t.reset().unwrap();
 210 }
 211
 212 fn read_config(filename: &str) -> Config {
 213     let sig_comments = read_significant_comments(&filename);
 214     // Look for a config file... If there is a 'config' property in the significant comments, use
 215     // that. Otherwise, if there are no significant comments at all, look for a config file with
 216     // the same name as the test file.
 217     let mut config = if !sig_comments.is_empty() {
 218         get_config(sig_comments.get("config").map(|x| &(*x)[..]))
 219     } else {
 220         get_config(
 221             Path::new(filename)
 222                 .with_extension("toml")
 223                 .file_name()
 224                 .and_then(std::ffi::OsStr::to_str),
 225         )
 226     };
 227
 228     for (key, val) in &sig_comments {
 229         if key != "target" && key != "config" {
 230             config.override_value(key, val);
 231         }
 232     }
 233
 234     // Don't generate warnings for to-do items.
 235     config.set().report_todo(ReportTactic::Never);
 236
 237     config
 238 }
 239
 240 fn format_file<P: Into<PathBuf>>(filepath: P, config: &Config) -> (FileMap, FormatReport) {
 241     let filepath = filepath.into();
 242     let input = Input::File(filepath);
 243     let (_error_summary, file_map, report) =
 244         format_input::<io::Stdout>(input, &config, None).unwrap();
 245     return (file_map, report);
 246 }
 247
 248 pub fn idempotent_check(filename: String) -> Result<FormatReport, HashMap<String, Vec<Mismatch>>> {
 249     let sig_comments = read_significant_comments(&filename);
 250     let config = read_config(&filename);
 251     let (file_map, format_report) = format_file(filename, &config);
 252
 253     let mut write_result = HashMap::new();
 254     for &(ref filename, ref text) in &file_map {
 255         let mut v = Vec::new();
 256         // Won't panic, as we're not doing any IO.
 257         write_system_newlines(&mut v, text, &config).unwrap();
 258         // Won't panic, we are writing correct utf8.
 259         let one_result = String::from_utf8(v).unwrap();
 260         write_result.insert(filename.clone(), one_result);
 261     }
 262
 263     let target = sig_comments.get("target").map(|x| &(*x)[..]);
 264
 265     handle_result(write_result, target).map(|_| format_report)
 266 }
 267
 268 // Reads test config file using the supplied (optional) file name. If there's no file name or the
 269 // file doesn't exist, just return the default config. Otherwise, the file must be read
 270 // successfully.
 271 fn get_config(config_file: Option<&str>) -> Config {
 272     let config_file_name = match config_file {
 273         None => return Default::default(),
 274         Some(file_name) => {
 275             let mut full_path = "tests/config/".to_owned();
 276             full_path.push_str(&file_name);
 277             if !Path::new(&full_path).exists() {
 278                 return Default::default();
 279             };
 280             full_path
 281         }
 282     };
 283
 284     let mut def_config_file = fs::File::open(config_file_name).expect("Couldn't open config");
 285     let mut def_config = String::new();
 286     def_config_file
 287         .read_to_string(&mut def_config)
 288         .expect("Couldn't read config");
 289
 290     Config::from_toml(&def_config).expect("Invalid toml")
 291 }
 292
 293 // Reads significant comments of the form: // rustfmt-key: value
 294 // into a hash map.
 295 fn read_significant_comments(file_name: &str) -> HashMap<String, String> {
 296     let file = fs::File::open(file_name).expect(&format!("Couldn't read file {}", file_name));
 297     let reader = BufReader::new(file);
 298     let pattern = r"^\s*//\s*rustfmt-([^:]+):\s*(\S+)";
 299     let regex = regex::Regex::new(&pattern).expect("Failed creating pattern 1");
 300
 301     // Matches lines containing significant comments or whitespace.
 302     let line_regex = regex::Regex::new(r"(^\s*$)|(^\s*//\s*rustfmt-[^:]+:\s*\S+)")
 303         .expect("Failed creating pattern 2");
 304
 305     reader
 306         .lines()
 307         .map(|line| line.expect("Failed getting line"))
 308         .take_while(|line| line_regex.is_match(&line))
 309         .filter_map(|line| {
 310             regex.captures_iter(&line).next().map(|capture| {
 311                 (
 312                     capture
 313                         .get(1)
 314                         .expect("Couldn't unwrap capture")
 315                         .as_str()
 316                         .to_owned(),
 317                     capture
 318                         .get(2)
 319                         .expect("Couldn't unwrap capture")
 320                         .as_str()
 321                         .to_owned(),
 322                 )
 323             })
 324         })
 325         .collect()
 326 }
 327
 328 // Compare output to input.
 329 // TODO: needs a better name, more explanation.
 330 fn handle_result(
 331     result: HashMap<String, String>,
 332     target: Option<&str>,
 333 ) -> Result<(), HashMap<String, Vec<Mismatch>>> {
 334     let mut failures = HashMap::new();
 335
 336     for (file_name, fmt_text) in result {
 337         // If file is in tests/source, compare to file with same name in tests/target.
 338         let target = get_target(&file_name, target);
 339         let open_error = format!("Couldn't open target {:?}", &target);
 340         let mut f = fs::File::open(&target).expect(&open_error);
 341
 342         let mut text = String::new();
 343         let read_error = format!("Failed reading target {:?}", &target);
 344         f.read_to_string(&mut text).expect(&read_error);
 345
 346         if fmt_text != text {
 347             let diff = make_diff(&text, &fmt_text, DIFF_CONTEXT_SIZE);
 348             assert!(
 349                 !diff.is_empty(),
 350                 "Empty diff? Maybe due to a missing a newline at the end of a file?"
 351             );
 352             failures.insert(file_name, diff);
 353         }
 354     }
 355
 356     if failures.is_empty() {
 357         Ok(())
 358     } else {
 359         Err(failures)
 360     }
 361 }
 362
 363 // Map source file paths to their target paths.
 364 fn get_target(file_name: &str, target: Option<&str>) -> String {
 365     if file_name.contains("source") {
 366         let target_file_name = file_name.replace("source", "target");
 367         if let Some(replace_name) = target {
 368             Path::new(&target_file_name)
 369                 .with_file_name(replace_name)
 370                 .into_os_string()
 371                 .into_string()
 372                 .unwrap()
 373         } else {
 374             target_file_name
 375         }
 376     } else {
 377         // This is either and idempotence check or a self check
 378         file_name.to_owned()
 379     }
 380 }
 381
 382 #[test]
 383 fn rustfmt_diff_make_diff_tests() {
 384     let diff = make_diff("a\nb\nc\nd", "a\ne\nc\nd", 3);
 385     assert_eq!(
 386         diff,
 387         vec![
 388             Mismatch {
 389                 line_number: 1,
 390                 lines: vec![
 391                     DiffLine::Context("a".into()),
 392                     DiffLine::Resulting("b".into()),
 393                     DiffLine::Expected("e".into()),
 394                     DiffLine::Context("c".into()),
 395                     DiffLine::Context("d".into()),
 396                 ],
 397             },
 398         ]
 399     );
 400 }
 401
 402 #[test]
 403 fn rustfmt_diff_no_diff_test() {
 404     let diff = make_diff("a\nb\nc\nd", "a\nb\nc\nd", 3);
 405     assert_eq!(diff, vec![]);
 406 }