2014-01-04 14:16:57 -06:00
|
|
|
// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
2012-12-03 18:48:01 -06:00
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
2014-04-15 23:56:39 -05:00
|
|
|
use common::Config;
|
2013-05-24 21:35:29 -05:00
|
|
|
use common;
|
2013-09-03 05:34:23 -05:00
|
|
|
use util;
|
2013-05-24 21:35:29 -05:00
|
|
|
|
2013-01-30 16:10:03 -06:00
|
|
|
pub struct TestProps {
|
2011-08-01 16:10:59 -05:00
|
|
|
// Lines that should be expected, in order, on standard out
|
2014-05-14 22:47:24 -05:00
|
|
|
pub error_patterns: Vec<StrBuf> ,
|
2011-08-01 16:10:59 -05:00
|
|
|
// Extra flags to pass to the compiler
|
2014-05-14 22:47:24 -05:00
|
|
|
pub compile_flags: Option<StrBuf>,
|
2014-04-19 04:36:00 -05:00
|
|
|
// Extra flags to pass when the compiled code is run (such as --bench)
|
2014-05-14 22:47:24 -05:00
|
|
|
pub run_flags: Option<StrBuf>,
|
2011-08-01 16:10:59 -05:00
|
|
|
// If present, the name of a file that this test should match when
|
|
|
|
// pretty-printed
|
2014-03-28 13:10:15 -05:00
|
|
|
pub pp_exact: Option<Path>,
|
2012-02-27 23:23:49 -06:00
|
|
|
// Modules from aux directory that should be compiled
|
2014-05-14 22:47:24 -05:00
|
|
|
pub aux_builds: Vec<StrBuf> ,
|
2012-04-13 11:19:07 -05:00
|
|
|
// Environment settings to use during execution
|
2014-05-14 22:47:24 -05:00
|
|
|
pub exec_env: Vec<(StrBuf,StrBuf)> ,
|
2013-02-09 12:09:19 -06:00
|
|
|
// Lines to check if they appear in the expected debugger output
|
2014-05-14 22:47:24 -05:00
|
|
|
pub check_lines: Vec<StrBuf> ,
|
2014-01-17 12:18:02 -06:00
|
|
|
// Flag to force a crate to be built with the host architecture
|
2014-03-28 13:10:15 -05:00
|
|
|
pub force_host: bool,
|
2014-02-12 12:25:09 -06:00
|
|
|
// Check stdout for error-pattern output as well as stderr
|
2014-03-28 13:10:15 -05:00
|
|
|
pub check_stdout: bool,
|
2014-02-10 13:33:33 -06:00
|
|
|
// Don't force a --crate-type=dylib flag on the command line
|
2014-03-28 13:10:15 -05:00
|
|
|
pub no_prefer_dynamic: bool,
|
2014-05-10 19:39:08 -05:00
|
|
|
// Don't run --pretty expanded when running pretty printing tests
|
|
|
|
pub no_pretty_expanded: bool,
|
2013-01-26 00:51:32 -06:00
|
|
|
}
|
2011-07-30 23:11:14 -05:00
|
|
|
|
|
|
|
// Load any test directives embedded in the file
|
2013-01-30 16:10:03 -06:00
|
|
|
pub fn load_props(testfile: &Path) -> TestProps {
|
2014-03-05 17:28:08 -06:00
|
|
|
let mut error_patterns = Vec::new();
|
|
|
|
let mut aux_builds = Vec::new();
|
|
|
|
let mut exec_env = Vec::new();
|
2012-12-28 10:28:36 -06:00
|
|
|
let mut compile_flags = None;
|
2014-04-19 04:36:00 -05:00
|
|
|
let mut run_flags = None;
|
2012-12-28 10:28:36 -06:00
|
|
|
let mut pp_exact = None;
|
2014-03-05 17:28:08 -06:00
|
|
|
let mut check_lines = Vec::new();
|
2014-01-17 12:18:02 -06:00
|
|
|
let mut force_host = false;
|
2014-02-12 12:25:09 -06:00
|
|
|
let mut check_stdout = false;
|
2014-02-10 13:33:33 -06:00
|
|
|
let mut no_prefer_dynamic = false;
|
2014-05-10 19:39:08 -05:00
|
|
|
let mut no_pretty_expanded = false;
|
2013-11-21 19:23:21 -06:00
|
|
|
iter_header(testfile, |ln| {
|
2012-08-06 14:34:08 -05:00
|
|
|
match parse_error_pattern(ln) {
|
2012-12-28 10:28:36 -06:00
|
|
|
Some(ep) => error_patterns.push(ep),
|
|
|
|
None => ()
|
2011-10-21 06:14:28 -05:00
|
|
|
};
|
2011-07-30 23:11:14 -05:00
|
|
|
|
2012-09-21 21:37:57 -05:00
|
|
|
if compile_flags.is_none() {
|
2011-07-30 23:11:14 -05:00
|
|
|
compile_flags = parse_compile_flags(ln);
|
|
|
|
}
|
2011-08-01 16:10:59 -05:00
|
|
|
|
2014-04-19 04:36:00 -05:00
|
|
|
if run_flags.is_none() {
|
|
|
|
run_flags = parse_run_flags(ln);
|
|
|
|
}
|
|
|
|
|
2012-09-21 21:37:57 -05:00
|
|
|
if pp_exact.is_none() {
|
2011-08-01 16:10:59 -05:00
|
|
|
pp_exact = parse_pp_exact(ln, testfile);
|
|
|
|
}
|
2012-02-27 23:23:49 -06:00
|
|
|
|
2014-01-17 12:18:02 -06:00
|
|
|
if !force_host {
|
|
|
|
force_host = parse_force_host(ln);
|
|
|
|
}
|
|
|
|
|
2014-02-12 12:25:09 -06:00
|
|
|
if !check_stdout {
|
|
|
|
check_stdout = parse_check_stdout(ln);
|
|
|
|
}
|
|
|
|
|
2014-02-10 13:33:33 -06:00
|
|
|
if !no_prefer_dynamic {
|
|
|
|
no_prefer_dynamic = parse_no_prefer_dynamic(ln);
|
|
|
|
}
|
|
|
|
|
2014-05-10 19:39:08 -05:00
|
|
|
if !no_pretty_expanded {
|
|
|
|
no_pretty_expanded = parse_no_pretty_expanded(ln);
|
|
|
|
}
|
|
|
|
|
2013-05-11 21:45:28 -05:00
|
|
|
match parse_aux_build(ln) {
|
|
|
|
Some(ab) => { aux_builds.push(ab); }
|
|
|
|
None => {}
|
2012-02-27 23:23:49 -06:00
|
|
|
}
|
2012-04-13 11:19:07 -05:00
|
|
|
|
2013-05-11 21:45:28 -05:00
|
|
|
match parse_exec_env(ln) {
|
|
|
|
Some(ee) => { exec_env.push(ee); }
|
|
|
|
None => {}
|
2012-04-13 11:19:07 -05:00
|
|
|
}
|
2013-02-09 12:09:19 -06:00
|
|
|
|
|
|
|
match parse_check_line(ln) {
|
|
|
|
Some(cl) => check_lines.push(cl),
|
|
|
|
None => ()
|
|
|
|
};
|
2013-08-02 01:17:20 -05:00
|
|
|
|
|
|
|
true
|
2013-11-21 19:23:21 -06:00
|
|
|
});
|
2014-04-19 04:36:00 -05:00
|
|
|
|
|
|
|
TestProps {
|
2011-08-01 16:10:59 -05:00
|
|
|
error_patterns: error_patterns,
|
|
|
|
compile_flags: compile_flags,
|
2014-04-19 04:36:00 -05:00
|
|
|
run_flags: run_flags,
|
2012-02-27 23:23:49 -06:00
|
|
|
pp_exact: pp_exact,
|
2012-04-13 11:19:07 -05:00
|
|
|
aux_builds: aux_builds,
|
2013-02-09 12:09:19 -06:00
|
|
|
exec_env: exec_env,
|
2014-01-17 12:18:02 -06:00
|
|
|
check_lines: check_lines,
|
|
|
|
force_host: force_host,
|
2014-02-12 12:25:09 -06:00
|
|
|
check_stdout: check_stdout,
|
2014-02-10 13:33:33 -06:00
|
|
|
no_prefer_dynamic: no_prefer_dynamic,
|
2014-05-10 19:39:08 -05:00
|
|
|
no_pretty_expanded: no_pretty_expanded,
|
2014-04-19 04:36:00 -05:00
|
|
|
}
|
2011-07-30 23:11:14 -05:00
|
|
|
}
|
|
|
|
|
2014-04-15 23:56:39 -05:00
|
|
|
pub fn is_test_ignored(config: &Config, testfile: &Path) -> bool {
|
2014-05-14 22:47:24 -05:00
|
|
|
fn ignore_target(config: &Config) -> StrBuf {
|
|
|
|
format_strbuf!("ignore-{}", util::get_os(config.target.as_slice()))
|
2011-09-09 15:24:06 -05:00
|
|
|
}
|
2014-05-14 22:47:24 -05:00
|
|
|
fn ignore_stage(config: &Config) -> StrBuf {
|
|
|
|
format_strbuf!("ignore-{}",
|
|
|
|
config.stage_id.as_slice().split('-').next().unwrap())
|
2013-12-25 12:10:33 -06:00
|
|
|
}
|
2013-08-02 01:17:20 -05:00
|
|
|
|
2013-11-21 19:23:21 -06:00
|
|
|
let val = iter_header(testfile, |ln| {
|
2014-05-14 22:47:24 -05:00
|
|
|
if parse_name_directive(ln, "ignore-test") {
|
|
|
|
false
|
|
|
|
} else if parse_name_directive(ln, ignore_target(config).as_slice()) {
|
|
|
|
false
|
|
|
|
} else if parse_name_directive(ln, ignore_stage(config).as_slice()) {
|
|
|
|
false
|
|
|
|
} else if config.mode == common::Pretty &&
|
|
|
|
parse_name_directive(ln, "ignore-pretty") {
|
|
|
|
false
|
|
|
|
} else if config.target != config.host &&
|
|
|
|
parse_name_directive(ln, "ignore-cross-compile") {
|
|
|
|
false
|
|
|
|
} else {
|
|
|
|
true
|
|
|
|
}
|
2013-11-21 19:23:21 -06:00
|
|
|
});
|
2013-08-02 01:17:20 -05:00
|
|
|
|
|
|
|
!val
|
2011-07-30 23:11:14 -05:00
|
|
|
}
|
|
|
|
|
2013-11-19 20:15:10 -06:00
|
|
|
fn iter_header(testfile: &Path, it: |&str| -> bool) -> bool {
|
2014-01-15 15:25:09 -06:00
|
|
|
use std::io::{BufferedReader, File};
|
2013-10-06 18:08:56 -05:00
|
|
|
|
2013-10-30 01:31:07 -05:00
|
|
|
let mut rdr = BufferedReader::new(File::open(testfile).unwrap());
|
2013-12-08 01:12:07 -06:00
|
|
|
for ln in rdr.lines() {
|
2011-07-30 23:11:14 -05:00
|
|
|
// Assume that any directives will be found before the first
|
|
|
|
// module or function. This doesn't seem to be an optimization
|
|
|
|
// with a warm page cache. Maybe with a cold one.
|
2014-02-19 20:53:46 -06:00
|
|
|
let ln = ln.unwrap();
|
2014-05-16 12:45:16 -05:00
|
|
|
if ln.as_slice().starts_with("fn") ||
|
|
|
|
ln.as_slice().starts_with("mod") {
|
2013-08-02 01:17:20 -05:00
|
|
|
return true;
|
2014-05-16 12:45:16 -05:00
|
|
|
} else {
|
|
|
|
if !(it(ln.as_slice().trim())) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2011-07-30 23:11:14 -05:00
|
|
|
}
|
2012-08-01 19:30:05 -05:00
|
|
|
return true;
|
2011-07-30 23:11:14 -05:00
|
|
|
}
|
|
|
|
|
2014-05-14 22:47:24 -05:00
|
|
|
fn parse_error_pattern(line: &str) -> Option<StrBuf> {
|
|
|
|
parse_name_value_directive(line, "error-pattern".to_strbuf())
|
2011-07-30 23:11:14 -05:00
|
|
|
}
|
|
|
|
|
2014-05-14 22:47:24 -05:00
|
|
|
fn parse_aux_build(line: &str) -> Option<StrBuf> {
|
|
|
|
parse_name_value_directive(line, "aux-build".to_strbuf())
|
2012-02-27 23:23:49 -06:00
|
|
|
}
|
|
|
|
|
2014-05-14 22:47:24 -05:00
|
|
|
fn parse_compile_flags(line: &str) -> Option<StrBuf> {
|
|
|
|
parse_name_value_directive(line, "compile-flags".to_strbuf())
|
2011-07-30 23:11:14 -05:00
|
|
|
}
|
|
|
|
|
2014-05-14 22:47:24 -05:00
|
|
|
fn parse_run_flags(line: &str) -> Option<StrBuf> {
|
|
|
|
parse_name_value_directive(line, "run-flags".to_strbuf())
|
2014-04-19 04:36:00 -05:00
|
|
|
}
|
|
|
|
|
2014-05-14 22:47:24 -05:00
|
|
|
fn parse_check_line(line: &str) -> Option<StrBuf> {
|
|
|
|
parse_name_value_directive(line, "check".to_strbuf())
|
2013-02-09 12:09:19 -06:00
|
|
|
}
|
|
|
|
|
2014-01-17 12:18:02 -06:00
|
|
|
fn parse_force_host(line: &str) -> bool {
|
|
|
|
parse_name_directive(line, "force-host")
|
|
|
|
}
|
|
|
|
|
2014-02-12 12:25:09 -06:00
|
|
|
fn parse_check_stdout(line: &str) -> bool {
|
|
|
|
parse_name_directive(line, "check-stdout")
|
|
|
|
}
|
|
|
|
|
2014-02-10 13:33:33 -06:00
|
|
|
fn parse_no_prefer_dynamic(line: &str) -> bool {
|
|
|
|
parse_name_directive(line, "no-prefer-dynamic")
|
|
|
|
}
|
|
|
|
|
2014-05-10 19:39:08 -05:00
|
|
|
fn parse_no_pretty_expanded(line: &str) -> bool {
|
|
|
|
parse_name_directive(line, "no-pretty-expanded")
|
|
|
|
}
|
|
|
|
|
2014-05-14 22:47:24 -05:00
|
|
|
fn parse_exec_env(line: &str) -> Option<(StrBuf, StrBuf)> {
|
|
|
|
parse_name_value_directive(line, "exec-env".to_strbuf()).map(|nv| {
|
2012-04-13 11:19:07 -05:00
|
|
|
// nv is either FOO or FOO=BAR
|
2014-05-14 22:47:24 -05:00
|
|
|
let mut strs: Vec<StrBuf> = nv.as_slice()
|
|
|
|
.splitn('=', 1)
|
|
|
|
.map(|s| s.to_strbuf())
|
|
|
|
.collect();
|
2013-06-09 08:10:50 -05:00
|
|
|
|
2012-08-06 14:34:08 -05:00
|
|
|
match strs.len() {
|
2014-05-14 22:47:24 -05:00
|
|
|
1u => (strs.pop().unwrap(), "".to_strbuf()),
|
2013-05-11 21:45:28 -05:00
|
|
|
2u => {
|
2013-12-23 09:20:52 -06:00
|
|
|
let end = strs.pop().unwrap();
|
|
|
|
(strs.pop().unwrap(), end)
|
2013-05-11 21:45:28 -05:00
|
|
|
}
|
2013-10-21 15:08:31 -05:00
|
|
|
n => fail!("Expected 1 or 2 strings, not {}", n)
|
2012-04-13 11:19:07 -05:00
|
|
|
}
|
2013-11-21 19:23:21 -06:00
|
|
|
})
|
2012-04-13 11:19:07 -05:00
|
|
|
}
|
|
|
|
|
2013-05-11 21:45:28 -05:00
|
|
|
fn parse_pp_exact(line: &str, testfile: &Path) -> Option<Path> {
|
2014-05-14 22:47:24 -05:00
|
|
|
match parse_name_value_directive(line, "pp-exact".to_strbuf()) {
|
2013-12-03 21:15:12 -06:00
|
|
|
Some(s) => Some(Path::new(s)),
|
2012-12-28 10:28:36 -06:00
|
|
|
None => {
|
2013-05-11 21:45:28 -05:00
|
|
|
if parse_name_directive(line, "pp-exact") {
|
2013-12-03 21:15:12 -06:00
|
|
|
testfile.filename().map(|s| Path::new(s))
|
2011-08-01 16:10:59 -05:00
|
|
|
} else {
|
2012-12-28 10:28:36 -06:00
|
|
|
None
|
2011-08-01 16:10:59 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-11 21:45:28 -05:00
|
|
|
fn parse_name_directive(line: &str, directive: &str) -> bool {
|
2013-06-10 02:32:36 -05:00
|
|
|
line.contains(directive)
|
2011-07-30 23:11:14 -05:00
|
|
|
}
|
|
|
|
|
2014-05-14 22:47:24 -05:00
|
|
|
pub fn parse_name_value_directive(line: &str, directive: StrBuf)
|
|
|
|
-> Option<StrBuf> {
|
|
|
|
let keycolon = format_strbuf!("{}:", directive);
|
|
|
|
match line.find_str(keycolon.as_slice()) {
|
2013-04-09 01:08:16 -05:00
|
|
|
Some(colon) => {
|
2013-06-09 09:44:58 -05:00
|
|
|
let value = line.slice(colon + keycolon.len(),
|
2014-05-14 22:47:24 -05:00
|
|
|
line.len()).to_strbuf();
|
|
|
|
debug!("{}: {}", directive, value);
|
2013-04-09 01:08:16 -05:00
|
|
|
Some(value)
|
2012-02-13 00:00:56 -06:00
|
|
|
}
|
2013-04-09 01:08:16 -05:00
|
|
|
None => None
|
2012-02-13 00:00:56 -06:00
|
|
|
}
|
2011-07-30 23:11:14 -05:00
|
|
|
}
|