use compile;
use native;
use builder::{Kind, Builder, Compiler, Step};
-use tool::Tool;
+use tool::{self, Tool};
const ADB_TEST_DIR: &str = "/data/tmp/work";
type Output = ();
const ONLY_HOSTS: bool = true;
+ fn should_run(_builder: &Builder, path: &Path) -> bool {
+ path.ends_with("src/tools/cargotest")
+ }
+
+ fn make_run(builder: &Builder, _path: Option<&Path>, host: &str, _target: &str) {
+ builder.ensure(Cargotest {
+ stage: builder.top_stage,
+ host: host,
+ });
+ }
+
/// Runs the `cargotest` tool as compiled in `stage` by the `host` compiler.
///
/// This tool in `src/tools` will check out a few Rust projects and run `cargo
fn run(self, builder: &Builder) {
let build = builder.build;
let compiler = self.compiler;
+
+ builder.ensure(compile::Test { compiler, target: compiler.host });
+
// Do a breadth-first traversal of the `src/doc` directory and just run
// tests for all files that end in `*.md`
let mut stack = vec![build.src.join("src/doc")];
("libtest", "src/libtest", String::new(), "test")
}
Mode::Librustc => {
+ builder.ensure(compile::Rustc { compiler, target });
("librustc", "src/rustc", build.rustc_features(), "rustc-main")
}
_ => panic!("can only test libraries"),
dst
}
-// // Some test suites are run inside emulators or on remote devices, and most
-// // of our test binaries are linked dynamically which means we need to ship
-// // the standard library and such to the emulator ahead of time. This step
-// // represents this and is a dependency of all test suites.
-// //
-// // Most of the time this step is a noop (the `check::emulator_copy_libs`
-// // only does work if necessary). For some steps such as shipping data to
-// // QEMU we have to build our own tools so we've got conditional dependencies
-// // on those programs as well. Note that the remote test client is built for
-// // the build target (us) and the server is built for the target.
// rules.test("remote-copy-libs", "path/to/nowhere")
// .dep(|s| s.name("libtest"))
// .dep(move |s| {
// .run(move |s| check::remote_copy_libs(build, &s.compiler(), s.target));
//
+/// Some test suites are run inside emulators or on remote devices, and most
+/// of our test binaries are linked dynamically which means we need to ship
+/// the standard library and such to the emulator ahead of time. This step
+/// represents this and is a dependency of all test suites.
+///
+/// Most of the time this is a noop. For some steps such as shipping data to
+/// QEMU we have to build our own tools so we've got conditional dependencies
+/// on those programs as well. Note that the remote test client is built for
+/// the build target (us) and the server is built for the target.
#[derive(Serialize)]
pub struct RemoteCopyLibs<'a> {
compiler: Compiler<'a>,
println!("REMOTE copy libs to emulator ({})", target);
t!(fs::create_dir_all(build.out.join("tmp")));
- // FIXME: This builds the tool for the native build triple
- // (build.build); that is probably wrong. Should build for target.
- let server = builder.tool_exe(Tool::RemoteTestServer);
+ let server = builder.ensure(tool::RemoteTestServer { compiler, target }));
// Spawn the emulator and wait for it to come online
let tool = builder.tool_exe(Tool::RemoteTestClient);
fn run(self, builder: &Builder) {
let build = builder.build;
+ builder.ensure(dist::PlainSourceTarball);
+ builder.ensure(dist::Src);
+
if build.build != "x86_64-unknown-linux-gnu" {
return
}
return
}
- builder.ensure(dist::PlainSourceTarball);
- builder.ensure(dist::Src);
-
println!("Distcheck");
let dir = build.out.join("tmp").join("distcheck");
let _ = fs::remove_dir_all(&dir);
// .dep(|s| s.name("libstd-tool"))
// .run(move |s| compile::tool(build, s.stage, s.target, "build-manifest"));
BuildManifest, "src/tools/build-manifest", "build-manifest", Mode::Librustc;
- // rules.build("tool-remote-test-server", "src/tools/remote-test-server")
- // .dep(|s| s.name("maybe-clean-tools"))
- // .dep(|s| s.name("libstd-tool"))
- // .run(move |s| compile::tool(build, s.stage, s.target, "remote-test-server"));
- RemoteTestServer, "src/tools/remote-test-server", "remote-test-server", Mode::Libstd;
// rules.build("tool-remote-test-client", "src/tools/remote-test-client")
// .dep(|s| s.name("maybe-clean-tools"))
// .dep(|s| s.name("libstd-tool"))
RustInstaller, "src/tools/rust-installer", "rust-installer", Mode::Libstd;
);
+#[derive(Serialize)]
+pub struct RemoteTestServer<'a> {
+ pub compiler: Compiler<'a>,
+ pub target: &'a str,
+}
+
+impl<'a> Step<'a> for RemoteTestServer<'a> {
+ type Output = PathBuf;
+
+ fn should_run(_builder: &Builder, path: &Path) -> bool {
+ path.ends_with("src/tools/remote-test-server")
+ }
+
+ fn make_run(builder: &Builder, _path: Option<&Path>, host: &str, target: &str) {
+ builder.ensure(RemoteTestServer {
+ compiler: builder.compiler(builder.top_stage, host),
+ target,
+ });
+ }
+
+ fn run(self, builder: &Builder) -> PathBuf {
+ builder.ensure(ToolBuild {
+ stage: self.stage,
+ target: self.target,
+ tool: "remote-test-server",
+ mode: Mode::Libstd,
+ })
+ }
+}
+
// rules.build("tool-cargo", "src/tools/cargo")
// .host(true)
// .default(build.config.extended)