pub use self::Mode::*;
use std::env;
use std::fmt;
use std::fs::{read_dir, remove_file};
use std::str::FromStr;
use std::path::PathBuf;
#[cfg(not(feature = "norustc"))]
use rustc;
use test::ColorConfig;
use runtest::dylib_env_var;
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum Mode {
CompileFail,
ParseFail,
RunFail,
RunPass,
RunPassValgrind,
Pretty,
DebugInfoGdb,
DebugInfoLldb,
Codegen,
Rustdoc,
CodegenUnits,
Incremental,
RunMake,
Ui,
MirOpt,
}
impl Mode {
pub fn disambiguator(self) -> &'static str {
match self {
Pretty => ".pretty",
DebugInfoGdb => ".gdb",
DebugInfoLldb => ".lldb",
_ => "",
}
}
}
impl FromStr for Mode {
type Err = ();
fn from_str(s: &str) -> Result<Mode, ()> {
match s {
"compile-fail" => Ok(CompileFail),
"parse-fail" => Ok(ParseFail),
"run-fail" => Ok(RunFail),
"run-pass" => Ok(RunPass),
"run-pass-valgrind" => Ok(RunPassValgrind),
"pretty" => Ok(Pretty),
"debuginfo-lldb" => Ok(DebugInfoLldb),
"debuginfo-gdb" => Ok(DebugInfoGdb),
"codegen" => Ok(Codegen),
"rustdoc" => Ok(Rustdoc),
"codegen-units" => Ok(CodegenUnits),
"incremental" => Ok(Incremental),
"run-make" => Ok(RunMake),
"ui" => Ok(Ui),
"mir-opt" => Ok(MirOpt),
_ => Err(()),
}
}
}
impl fmt::Display for Mode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Display::fmt(match *self {
CompileFail => "compile-fail",
ParseFail => "parse-fail",
RunFail => "run-fail",
RunPass => "run-pass",
RunPassValgrind => "run-pass-valgrind",
Pretty => "pretty",
DebugInfoGdb => "debuginfo-gdb",
DebugInfoLldb => "debuginfo-lldb",
Codegen => "codegen",
Rustdoc => "rustdoc",
CodegenUnits => "codegen-units",
Incremental => "incremental",
RunMake => "run-make",
Ui => "ui",
MirOpt => "mir-opt",
},
f)
}
}
#[derive(Clone)]
pub struct Config {
pub compile_lib_path: PathBuf,
pub run_lib_path: PathBuf,
pub rustc_path: PathBuf,
pub rustdoc_path: Option<PathBuf>,
pub lldb_python: String,
pub docck_python: String,
pub llvm_filecheck: Option<PathBuf>,
pub valgrind_path: Option<String>,
pub force_valgrind: bool,
pub src_base: PathBuf,
pub build_base: PathBuf,
pub stage_id: String,
pub mode: Mode,
pub run_ignored: bool,
pub filter: Option<String>,
pub filter_exact: bool,
pub logfile: Option<PathBuf>,
pub runtool: Option<String>,
pub host_rustcflags: Option<String>,
pub target_rustcflags: Option<String>,
pub target: String,
pub host: String,
pub gdb: Option<String>,
pub gdb_version: Option<u32>,
pub gdb_native_rust: bool,
pub lldb_version: Option<String>,
pub llvm_version: Option<String>,
pub system_llvm: bool,
pub android_cross_path: PathBuf,
pub adb_path: String,
pub adb_test_dir: String,
pub adb_device_status: bool,
pub lldb_python_dir: Option<String>,
pub verbose: bool,
pub quiet: bool,
pub color: ColorConfig,
pub remote_test_client: Option<PathBuf>,
pub cc: String,
pub cxx: String,
pub cflags: String,
pub ar: String,
pub linker: Option<String>,
pub llvm_components: String,
pub llvm_cxxflags: String,
pub nodejs: Option<String>,
}
#[derive(Clone)]
pub struct TestPaths {
pub file: PathBuf, pub base: PathBuf, pub relative_dir: PathBuf, }
impl Config {
pub fn link_deps(&mut self) {
let varname = dylib_env_var();
let lib_paths = env::var(varname).unwrap_or_else(|e| {
panic!("Cannot link to dependencies. Problem with env var '{}': {:?}", varname, e)
});
let mut flags = self.target_rustcflags.take().unwrap_or_else(String::new);
for p in env::split_paths(&lib_paths) {
flags += " -L ";
flags += p.to_str().unwrap(); }
self.target_rustcflags = Some(flags);
}
pub fn clean_rmeta(&self) {
if self.target_rustcflags.is_some() {
for directory in self.target_rustcflags
.as_ref()
.unwrap()
.split_whitespace()
.filter(|s| s.ends_with("/deps"))
{
if let Ok(mut entries) = read_dir(directory) {
while let Some(Ok(entry)) = entries.next() {
if entry.file_name().to_string_lossy().ends_with(".rmeta") {
let _ = remove_file(entry.path());
}
}
}
}
}
}
#[cfg(feature = "tmp")]
pub fn tempdir(mut self) -> config_tempdir::ConfigWithTemp {
use tempfile;
let tmp = tempfile::Builder::new().prefix("compiletest").tempdir()
.expect("failed to create temporary directory");
self.build_base = tmp.path().to_owned();
config_tempdir::ConfigWithTemp {
config: self,
tempdir: tmp,
}
}
}
#[cfg(feature = "tmp")]
mod config_tempdir {
use tempfile;
use std::ops;
pub struct ConfigWithTemp {
pub config: super::Config,
pub tempdir: tempfile::TempDir,
}
impl ops::Deref for ConfigWithTemp {
type Target = super::Config;
fn deref(&self) -> &Self::Target {
&self.config
}
}
impl ops::DerefMut for ConfigWithTemp {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.config
}
}
}
impl Default for Config {
fn default() -> Config {
#[cfg(not(feature = "norustc"))]
let platform = rustc::session::config::host_triple().to_string();
Config {
compile_lib_path: PathBuf::from(""),
run_lib_path: PathBuf::from(""),
rustc_path: PathBuf::from("rustc"),
rustdoc_path: None,
lldb_python: "python".to_owned(),
docck_python: "docck-python".to_owned(),
valgrind_path: None,
force_valgrind: false,
llvm_filecheck: None,
src_base: PathBuf::from("tests/run-pass"),
build_base: env::temp_dir(),
stage_id: "stage-id".to_owned(),
mode: Mode::RunPass,
run_ignored: false,
filter: None,
filter_exact: false,
logfile: None,
runtool: None,
host_rustcflags: None,
target_rustcflags: None,
#[cfg(not(feature = "norustc"))]
target: platform.clone(),
#[cfg(feature = "norustc")]
target: env!("TARGET").to_string(),
#[cfg(not(feature = "norustc"))]
host: platform.clone(),
#[cfg(feature = "norustc")]
host: env!("HOST").to_string(),
gdb: None,
gdb_version: None,
gdb_native_rust: false,
lldb_version: None,
llvm_version: None,
system_llvm: false,
android_cross_path: PathBuf::from("android-cross-path"),
adb_path: "adb-path".to_owned(),
adb_test_dir: "adb-test-dir/target".to_owned(),
adb_device_status: false,
lldb_python_dir: None,
verbose: false,
quiet: false,
color: ColorConfig::AutoColor,
remote_test_client: None,
cc: "cc".to_string(),
cxx: "cxx".to_string(),
cflags: "cflags".to_string(),
ar: "ar".to_string(),
linker: None,
llvm_components: "llvm-components".to_string(),
llvm_cxxflags: "llvm-cxxflags".to_string(),
nodejs: None,
}
}
}