use std::collections::HashMap;
use std::fs;
use std::io::{self, Read, BufRead, BufReader};
-use std::path::Path;
+use std::path::{Path, PathBuf};
use rustfmt::*;
-use rustfmt::filemap::write_system_newlines;
-use rustfmt::config::{Config, ReportTactic, WriteMode};
+use rustfmt::filemap::{write_system_newlines, FileMap};
+use rustfmt::config::{Config, ReportTactic};
use rustfmt::rustfmt_diff::*;
-static DIFF_CONTEXT_SIZE: usize = 3;
+const DIFF_CONTEXT_SIZE: usize = 3;
fn get_path_string(dir_entry: io::Result<fs::DirEntry>) -> String {
- let path = dir_entry.ok().expect("Couldn't get DirEntry.").path();
+ let path = dir_entry.expect("Couldn't get DirEntry").path();
- path.to_str().expect("Couldn't stringify path.").to_owned()
+ path.to_str().expect("Couldn't stringify path").to_owned()
}
// Integration tests. The files in the tests/source are formatted and compared
#[test]
fn system_tests() {
// Get all files in the tests/source directory.
- let files = fs::read_dir("tests/source").ok().expect("Couldn't read source dir.");
+ let files = fs::read_dir("tests/source").expect("Couldn't read source dir");
// Turn a DirEntry into a String that represents the relative path to the
// file.
let files = files.map(get_path_string);
- let (_reports, count, fails) = check_files(files, WriteMode::Default);
+ let (_reports, count, fails) = check_files(files);
// Display results.
println!("Ran {} system tests.", count);
// the only difference is the coverage mode
#[test]
fn coverage_tests() {
- let files = fs::read_dir("tests/coverage-source").ok().expect("Couldn't read source dir.");
+ let files = fs::read_dir("tests/coverage/source").expect("Couldn't read source dir");
let files = files.map(get_path_string);
- let (_reports, count, fails) = check_files(files, WriteMode::Coverage);
+ let (_reports, count, fails) = check_files(files);
println!("Ran {} tests in coverage mode.", count);
assert!(fails == 0, "{} tests failed", fails);
#[test]
fn checkstyle_test() {
- let filename = "tests/target/fn-single-line.rs".to_string();
- let expected = "tests/writemode/checkstyle.xml";
+ let filename = "tests/writemode/source/fn-single-line.rs";
+ let expected_filename = "tests/writemode/target/checkstyle.xml";
+ assert_output(filename, expected_filename);
+}
+
- let output = run_rustfmt(filename.clone(), WriteMode::Checkstyle);
+// Helper function for comparing the results of rustfmt
+// to a known output file generated by one of the write modes.
+fn assert_output(source: &str, expected_filename: &str) {
+ let config = read_config(&source);
+ let (file_map, _report) = format_file(source, &config);
- let mut expected_file = fs::File::open(&expected)
- .ok()
- .expect("Couldn't open target.");
+ // Populate output by writing to a vec.
+ let mut out = vec![];
+ let _ = filemap::write_all_files(&file_map, &mut out, &config);
+ let output = String::from_utf8(out).unwrap();
+
+ let mut expected_file = fs::File::open(&expected_filename).expect("Couldn't open target");
let mut expected_text = String::new();
expected_file.read_to_string(&mut expected_text)
- .ok()
- .expect("Failed reading target.");
-
- let mut failures = HashMap::new();
- if expected_text != output {
- let diff = make_diff(&expected_text, &output, DIFF_CONTEXT_SIZE);
- failures.insert(filename, diff);
- // print_mismatches(failures);
- // assert!(false, "Text does not match expected output");
+ .expect("Failed reading target");
+
+ let compare = make_diff(&expected_text, &output, DIFF_CONTEXT_SIZE);
+ if compare.len() > 0 {
+ let mut failures = HashMap::new();
+ failures.insert(source.to_string(), compare);
+ print_mismatches(failures);
+ assert!(false, "Text does not match expected output");
}
}
fn idempotence_tests() {
// Get all files in the tests/target directory.
let files = fs::read_dir("tests/target")
- .ok()
- .expect("Couldn't read target dir.")
- .map(get_path_string);
- let (_reports, count, fails) = check_files(files, WriteMode::Default);
+ .expect("Couldn't read target dir")
+ .map(get_path_string);
+ let (_reports, count, fails) = check_files(files);
// Display results.
println!("Ran {} idempotent tests.", count);
#[test]
fn self_tests() {
let files = fs::read_dir("src/bin")
- .ok()
- .expect("Couldn't read src dir.")
- .chain(fs::read_dir("tests").ok().expect("Couldn't read tests dir."))
- .map(get_path_string);
+ .expect("Couldn't read src dir")
+ .chain(fs::read_dir("tests").expect("Couldn't read tests dir"))
+ .map(get_path_string);
// Hack because there's no `IntoIterator` impl for `[T; N]`.
let files = files.chain(Some("src/lib.rs".to_owned()).into_iter());
- let (reports, count, fails) = check_files(files, WriteMode::Default);
+ let (reports, count, fails) = check_files(files);
let mut warnings = 0;
// Display results.
warnings);
}
+#[test]
+fn stdin_formatting_smoke_test() {
+ let input = Input::Text("fn main () {}".to_owned());
+ let config = Config::default();
+ let (error_summary, file_map, _report) = format_input(input, &config);
+ assert!(error_summary.has_no_errors());
+ assert_eq!(file_map["stdin"].to_string(), "fn main() {}\n")
+}
+
+#[test]
+fn format_lines_errors_are_reported() {
+ let long_identifier = String::from_utf8(vec![b'a'; 239]).unwrap();
+ let input = Input::Text(format!("fn {}() {{}}", long_identifier));
+ let config = Config::default();
+ let (error_summary, _file_map, _report) = format_input(input, &config);
+ assert!(error_summary.has_formatting_errors());
+}
+
// For each file, run rustfmt and collect the output.
// Returns the number of files checked and the number of failures.
-fn check_files<I>(files: I, write_mode: WriteMode) -> (Vec<FormatReport>, u32, u32)
+fn check_files<I>(files: I) -> (Vec<FormatReport>, u32, u32)
where I: Iterator<Item = String>
{
let mut count = 0;
for file_name in files.filter(|f| f.ends_with(".rs")) {
println!("Testing '{}'...", file_name);
- match idempotent_check(file_name, write_mode) {
+ match idempotent_check(file_name) {
Ok(report) => reports.push(report),
Err(msg) => {
print_mismatches(msg);
|line_num| format!("\nMismatch at {}:{}:", file_name, line_num));
}
- assert!(t.reset().unwrap());
+ t.reset().unwrap();
}
-pub fn run_rustfmt(filename: String, write_mode: WriteMode) -> String {
+fn read_config(filename: &str) -> Config {
let sig_comments = read_significant_comments(&filename);
let mut config = get_config(sig_comments.get("config").map(|x| &(*x)[..]));
// Don't generate warnings for to-do items.
config.report_todo = ReportTactic::Never;
- // Simulate run()
- let mut file_map = format(Path::new(&filename), &config, write_mode);
- // TODO this writes directly to stdout making it impossible to test :(
- let write_result = filemap::write_all_files(&file_map, write_mode, &config);
- let res = write_result.unwrap();
- String::new()
-
- // for (filename, text) in file_map.iter() {
- // let mut v = Vec::new();
- // // Won't panic, as we're not doing any IO.
- // write_system_newlines(&mut v, text, &config).unwrap();
- // // Won't panic, we are writing correct utf8.
- // let one_result = String::from_utf8(v).unwrap();
- // write_result.insert(filename, one_result);
- // }
- // write_result.remove(&filename).unwrap().to_owned()
+ config
}
-pub fn idempotent_check(filename: String,
- write_mode: WriteMode)
- -> Result<FormatReport, HashMap<String, Vec<Mismatch>>> {
- let sig_comments = read_significant_comments(&filename);
- let mut config = get_config(sig_comments.get("config").map(|x| &(*x)[..]));
-
- for (key, val) in &sig_comments {
- if key != "target" && key != "config" {
- config.override_value(key, val);
- }
- }
-
- // Don't generate warnings for to-do items.
- config.report_todo = ReportTactic::Never;
+fn format_file<P: Into<PathBuf>>(filename: P, config: &Config) -> (FileMap, FormatReport) {
+ let input = Input::File(filename.into());
+ let (_error_summary, file_map, report) = format_input(input, &config);
+ return (file_map, report);
+}
- let mut file_map = format(Path::new(&filename), &config, write_mode);
- let format_report = fmt_lines(&mut file_map, &config);
+pub fn idempotent_check(filename: String) -> Result<FormatReport, HashMap<String, Vec<Mismatch>>> {
+ let sig_comments = read_significant_comments(&filename);
+ let config = read_config(&filename);
+ let (file_map, format_report) = format_file(filename, &config);
let mut write_result = HashMap::new();
for (filename, text) in file_map.iter() {
let target = sig_comments.get("target").map(|x| &(*x)[..]);
- handle_result(write_result, target, write_mode).map(|_| format_report)
+ handle_result(write_result, target).map(|_| format_report)
}
// Reads test config file from comments and reads its contents.
}
};
- let mut def_config_file = fs::File::open(config_file_name)
- .ok()
- .expect("Couldn't open config.");
+ let mut def_config_file = fs::File::open(config_file_name).expect("Couldn't open config");
let mut def_config = String::new();
- def_config_file.read_to_string(&mut def_config).ok().expect("Couldn't read config.");
+ def_config_file.read_to_string(&mut def_config).expect("Couldn't read config");
Config::from_toml(&def_config)
}
// Reads significant comments of the form: // rustfmt-key: value
// into a hash map.
fn read_significant_comments(file_name: &str) -> HashMap<String, String> {
- let file = fs::File::open(file_name)
- .ok()
- .expect(&format!("Couldn't read file {}.", file_name));
+ let file = fs::File::open(file_name).expect(&format!("Couldn't read file {}", file_name));
let reader = BufReader::new(file);
let pattern = r"^\s*//\s*rustfmt-([^:]+):\s*(\S+)";
- let regex = regex::Regex::new(&pattern).ok().expect("Failed creating pattern 1.");
+ let regex = regex::Regex::new(&pattern).expect("Failed creating pattern 1");
// Matches lines containing significant comments or whitespace.
let line_regex = regex::Regex::new(r"(^\s*$)|(^\s*//\s*rustfmt-[^:]+:\s*\S+)")
- .ok()
- .expect("Failed creating pattern 2.");
+ .expect("Failed creating pattern 2");
reader.lines()
- .map(|line| line.ok().expect("Failed getting line."))
- .take_while(|line| line_regex.is_match(&line))
- .filter_map(|line| {
- regex.captures_iter(&line).next().map(|capture| {
- (capture.at(1).expect("Couldn't unwrap capture.").to_owned(),
- capture.at(2).expect("Couldn't unwrap capture.").to_owned())
- })
- })
- .collect()
+ .map(|line| line.expect("Failed getting line"))
+ .take_while(|line| line_regex.is_match(&line))
+ .filter_map(|line| {
+ regex.captures_iter(&line).next().map(|capture| {
+ (capture.at(1).expect("Couldn't unwrap capture").to_owned(),
+ capture.at(2).expect("Couldn't unwrap capture").to_owned())
+ })
+ })
+ .collect()
}
// Compare output to input.
// TODO: needs a better name, more explanation.
fn handle_result(result: HashMap<String, String>,
- target: Option<&str>,
- write_mode: WriteMode)
+ target: Option<&str>)
-> Result<(), HashMap<String, Vec<Mismatch>>> {
let mut failures = HashMap::new();
for (file_name, fmt_text) in result {
// If file is in tests/source, compare to file with same name in tests/target.
- let target = get_target(&file_name, target, write_mode);
- let mut f = fs::File::open(&target).ok().expect("Couldn't open target.");
+ let target = get_target(&file_name, target);
+ let mut f = fs::File::open(&target).expect("Couldn't open target");
let mut text = String::new();
- f.read_to_string(&mut text).ok().expect("Failed reading target.");
+ f.read_to_string(&mut text).expect("Failed reading target");
if fmt_text != text {
let diff = make_diff(&text, &fmt_text, DIFF_CONTEXT_SIZE);
+ assert!(!diff.is_empty(),
+ "Empty diff? Maybe due to a missing a newline at the end of a file?");
failures.insert(file_name, diff);
}
}
}
// Map source file paths to their target paths.
-fn get_target(file_name: &str, target: Option<&str>, write_mode: WriteMode) -> String {
- let file_path = Path::new(file_name);
- let (source_path_prefix, target_path_prefix) = match write_mode {
- WriteMode::Coverage => {
- (Path::new("tests/coverage-source/"),
- "tests/coverage-target/")
+fn get_target(file_name: &str, target: Option<&str>) -> String {
+ if file_name.contains("source") {
+ let target_file_name = file_name.replace("source", "target");
+ if let Some(replace_name) = target {
+ Path::new(&target_file_name)
+ .with_file_name(replace_name)
+ .into_os_string()
+ .into_string()
+ .unwrap()
+ } else {
+ target_file_name
}
- _ => (Path::new("tests/source/"), "tests/target/"),
- };
-
- if file_path.starts_with(source_path_prefix) {
- let mut components = file_path.components();
- // Can't skip(2) as the resulting iterator can't as_path()
- components.next();
- components.next();
-
- let new_target = match components.as_path().to_str() {
- Some(string) => string,
- None => file_name,
- };
- let base = target.unwrap_or(new_target);
-
- format!("{}{}", target_path_prefix, base)
} else {
+ // This is either and idempotence check or a self check
file_name.to_owned()
}
}
projects / rust.git / blobdiff