pub struct TestProps {
// Lines that should be expected, in order, on standard out
pub error_patterns: Vec<String>,
+ // Regexes that should be expected, in order, on standard out
+ pub regex_error_patterns: Vec<String>,
// Extra flags to pass to the compiler
pub compile_flags: Vec<String>,
// Extra flags to pass when the compiled code is run (such as --bench)
mod directives {
pub const ERROR_PATTERN: &'static str = "error-pattern";
+ pub const REGEX_ERROR_PATTERN: &'static str = "regex-error-pattern";
pub const COMPILE_FLAGS: &'static str = "compile-flags";
pub const RUN_FLAGS: &'static str = "run-flags";
pub const SHOULD_ICE: &'static str = "should-ice";
pub fn new() -> Self {
TestProps {
error_patterns: vec![],
+ regex_error_patterns: vec![],
compile_flags: vec![],
run_flags: None,
pp_exact: None,
&mut self.error_patterns,
|r| r,
);
+ config.push_name_value_directive(
+ ln,
+ REGEX_ERROR_PATTERN,
+ &mut self.regex_error_patterns,
+ |r| r,
+ );
if let Some(flags) = config.parse_name_value_directive(ln, COMPILE_FLAGS) {
self.compile_flags.extend(flags.split_whitespace().map(|s| s.to_owned()));
}
if let Some(edition) = config.parse_edition(ln) {
- self.compile_flags.push(format!("--edition={}", edition));
+ self.compile_flags.push(format!("--edition={}", edition.trim()));
has_edition = true;
}
}
}
+pub fn line_directive<'line>(
+ comment: &str,
+ ln: &'line str,
+) -> Option<(Option<&'line str>, &'line str)> {
+ if ln.starts_with(comment) {
+ let ln = ln[comment.len()..].trim_start();
+ if ln.starts_with('[') {
+ // A comment like `//[foo]` is specific to revision `foo`
+ if let Some(close_brace) = ln.find(']') {
+ let lncfg = &ln[1..close_brace];
+
+ Some((Some(lncfg), ln[(close_brace + 1)..].trim_start()))
+ } else {
+ panic!("malformed condition directive: expected `{}[foo]`, found `{}`", comment, ln)
+ }
+ } else {
+ Some((None, ln))
+ }
+ } else {
+ None
+ }
+}
+
fn iter_header<R: Read>(testfile: &Path, rdr: R, it: &mut dyn FnMut(Option<&str>, &str)) {
if testfile.is_dir() {
return;
let ln = ln.trim();
if ln.starts_with("fn") || ln.starts_with("mod") {
return;
- } else if ln.starts_with(comment) && ln[comment.len()..].trim_start().starts_with('[') {
- // A comment like `//[foo]` is specific to revision `foo`
- if let Some(close_brace) = ln.find(']') {
- let open_brace = ln.find('[').unwrap();
- let lncfg = &ln[open_brace + 1..close_brace];
- it(Some(lncfg), ln[(close_brace + 1)..].trim_start());
- } else {
- panic!("malformed condition directive: expected `{}[foo]`, found `{}`", comment, ln)
- }
- } else if ln.starts_with(comment) {
- it(None, ln[comment.len()..].trim_start());
+ } else if let Some((lncfg, ln)) = line_directive(comment, ln) {
+ it(lncfg, ln);
}
}
}