cd6e9f4f83
r? @metajack When invoked with the --rust-path-hack flag, rustpkg was correctly building the package into the default workspace (and not into the build/ subdirectory of the parent directory of the source directory), but not correctly putting the output for any dependencies into the default workspace as well. Spotted by Jack.
2388 lines
95 KiB
Rust
2388 lines
95 KiB
Rust
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// 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.
|
|
|
|
// rustpkg unit tests
|
|
|
|
use context::{BuildContext, Context, RustcFlags};
|
|
use std::{os, run, str, task};
|
|
use std::rt::io;
|
|
use std::rt::io::Writer;
|
|
use std::rt::io::file::FileInfo;
|
|
use extra::arc::Arc;
|
|
use extra::arc::RWArc;
|
|
use extra::tempfile::TempDir;
|
|
use extra::workcache;
|
|
use extra::workcache::{Database, Logger};
|
|
use extra::treemap::TreeMap;
|
|
use extra::getopts::groups::getopts;
|
|
use std::run::ProcessOutput;
|
|
use installed_packages::list_installed_packages;
|
|
use package_id::{PkgId};
|
|
use version::{ExactRevision, NoVersion, Version, Tagged};
|
|
use path_util::{target_executable_in_workspace, target_test_in_workspace,
|
|
target_bench_in_workspace, make_dir_rwx, U_RWX,
|
|
library_in_workspace, installed_library_in_workspace,
|
|
built_bench_in_workspace, built_test_in_workspace,
|
|
built_library_in_workspace, built_executable_in_workspace, target_build_dir,
|
|
chmod_read_only, platform_library_name};
|
|
use rustc::back::link::get_cc_prog;
|
|
use rustc::metadata::filesearch::rust_path;
|
|
use rustc::driver::driver::{build_session, build_session_options, host_triple, optgroups};
|
|
use syntax::diagnostic;
|
|
use target::*;
|
|
use package_source::PkgSrc;
|
|
use source_control::{CheckedOutSources, DirToUse, safe_git_clone};
|
|
use exit_codes::{BAD_FLAG_CODE, COPY_FAILED_CODE};
|
|
|
|
fn fake_ctxt(sysroot: Path, workspace: &Path) -> BuildContext {
|
|
let context = workcache::Context::new(
|
|
RWArc::new(Database::new(workspace.join("rustpkg_db.json"))),
|
|
RWArc::new(Logger::new()),
|
|
Arc::new(TreeMap::new()));
|
|
BuildContext {
|
|
workcache_context: context,
|
|
context: Context {
|
|
cfgs: ~[],
|
|
rustc_flags: RustcFlags::default(),
|
|
|
|
use_rust_path_hack: false,
|
|
sysroot: sysroot
|
|
}
|
|
}
|
|
}
|
|
|
|
fn fake_pkg() -> PkgId {
|
|
let sn = ~"bogus";
|
|
PkgId {
|
|
path: Path::new(sn.as_slice()),
|
|
short_name: sn,
|
|
version: NoVersion
|
|
}
|
|
}
|
|
|
|
fn git_repo_pkg() -> PkgId {
|
|
PkgId {
|
|
path: Path::new("mockgithub.com/catamorphism/test-pkg"),
|
|
short_name: ~"test-pkg",
|
|
version: NoVersion
|
|
}
|
|
}
|
|
|
|
fn git_repo_pkg_with_tag(a_tag: ~str) -> PkgId {
|
|
PkgId {
|
|
path: Path::new("mockgithub.com/catamorphism/test-pkg"),
|
|
short_name: ~"test-pkg",
|
|
version: Tagged(a_tag)
|
|
}
|
|
}
|
|
|
|
fn writeFile(file_path: &Path, contents: &str) {
|
|
let mut out = file_path.open_writer(io::CreateOrTruncate);
|
|
out.write(contents.as_bytes());
|
|
out.write(['\n' as u8]);
|
|
}
|
|
|
|
fn mk_emptier_workspace(tag: &str) -> TempDir {
|
|
let workspace = TempDir::new(tag).expect("couldn't create temp dir");
|
|
let package_dir = workspace.path().join("src");
|
|
assert!(os::mkdir_recursive(&package_dir, U_RWX));
|
|
workspace
|
|
}
|
|
|
|
fn mk_empty_workspace(short_name: &Path, version: &Version, tag: &str) -> TempDir {
|
|
let workspace_dir = TempDir::new(tag).expect("couldn't create temp dir");
|
|
mk_workspace(workspace_dir.path(), short_name, version);
|
|
workspace_dir
|
|
}
|
|
|
|
fn mk_workspace(workspace: &Path, short_name: &Path, version: &Version) -> Path {
|
|
// include version number in directory name
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let package_dir = workspace.join_many([~"src", format!("{}-{}",
|
|
short_name.as_str().unwrap(), version.to_str())]);
|
|
assert!(os::mkdir_recursive(&package_dir, U_RWX));
|
|
package_dir
|
|
}
|
|
|
|
fn mk_temp_workspace(short_name: &Path, version: &Version) -> (TempDir, Path) {
|
|
let workspace_dir = mk_empty_workspace(short_name, version, "temp_workspace");
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let package_dir = workspace_dir.path().join_many([~"src",
|
|
format!("{}-{}",
|
|
short_name.as_str().unwrap(),
|
|
version.to_str())]);
|
|
|
|
debug!("Created {} and does it exist? {:?}", package_dir.display(),
|
|
os::path_is_dir(&package_dir));
|
|
// Create main, lib, test, and bench files
|
|
debug!("mk_workspace: creating {}", package_dir.display());
|
|
assert!(os::mkdir_recursive(&package_dir, U_RWX));
|
|
debug!("Created {} and does it exist? {:?}", package_dir.display(),
|
|
os::path_is_dir(&package_dir));
|
|
// Create main, lib, test, and bench files
|
|
|
|
writeFile(&package_dir.join("main.rs"),
|
|
"fn main() { let _x = (); }");
|
|
writeFile(&package_dir.join("lib.rs"),
|
|
"pub fn f() { let _x = (); }");
|
|
writeFile(&package_dir.join("test.rs"),
|
|
"#[test] pub fn f() { (); }");
|
|
writeFile(&package_dir.join("bench.rs"),
|
|
"#[bench] pub fn f() { (); }");
|
|
(workspace_dir, package_dir)
|
|
}
|
|
|
|
fn run_git(args: &[~str], env: Option<~[(~str, ~str)]>, cwd: &Path, err_msg: &str) {
|
|
let cwd = (*cwd).clone();
|
|
let mut prog = run::Process::new("git", args, run::ProcessOptions {
|
|
env: env,
|
|
dir: Some(&cwd),
|
|
in_fd: None,
|
|
out_fd: None,
|
|
err_fd: None
|
|
});
|
|
let rslt = prog.finish_with_output();
|
|
if rslt.status != 0 {
|
|
fail!("{} [git returned {:?}, output = {}, error = {}]", err_msg,
|
|
rslt.status, str::from_utf8(rslt.output), str::from_utf8(rslt.error));
|
|
}
|
|
}
|
|
|
|
/// Should create an empty git repo in p, relative to the tmp dir, and return the new
|
|
/// absolute path
|
|
fn init_git_repo(p: &Path) -> TempDir {
|
|
assert!(p.is_relative());
|
|
let tmp = TempDir::new("git_local").expect("couldn't create temp dir");
|
|
let work_dir = tmp.path().join(p);
|
|
let work_dir_for_opts = work_dir.clone();
|
|
assert!(os::mkdir_recursive(&work_dir, U_RWX));
|
|
debug!("Running: git init in {}", work_dir.display());
|
|
run_git([~"init"], None, &work_dir_for_opts,
|
|
format!("Couldn't initialize git repository in {}", work_dir.display()));
|
|
// Add stuff to the dir so that git tag succeeds
|
|
writeFile(&work_dir.join("README"), "");
|
|
run_git([~"add", ~"README"], None, &work_dir_for_opts, format!("Couldn't add in {}",
|
|
work_dir.display()));
|
|
git_commit(&work_dir_for_opts, ~"whatever");
|
|
tmp
|
|
}
|
|
|
|
fn add_all_and_commit(repo: &Path) {
|
|
git_add_all(repo);
|
|
git_commit(repo, ~"floop");
|
|
}
|
|
|
|
fn git_commit(repo: &Path, msg: ~str) {
|
|
run_git([~"commit", ~"--author=tester <test@mozilla.com>", ~"-m", msg],
|
|
None, repo, format!("Couldn't commit in {}", repo.display()));
|
|
}
|
|
|
|
fn git_add_all(repo: &Path) {
|
|
run_git([~"add", ~"-A"], None, repo, format!("Couldn't add all files in {}", repo.display()));
|
|
}
|
|
|
|
fn add_git_tag(repo: &Path, tag: ~str) {
|
|
assert!(repo.is_absolute());
|
|
git_add_all(repo);
|
|
git_commit(repo, ~"whatever");
|
|
run_git([~"tag", tag.clone()], None, repo,
|
|
format!("Couldn't add git tag {} in {}", tag, repo.display()));
|
|
}
|
|
|
|
fn is_rwx(p: &Path) -> bool {
|
|
use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
|
|
|
|
match p.get_mode() {
|
|
None => return false,
|
|
Some(m) =>
|
|
((m & S_IRUSR as uint) == S_IRUSR as uint
|
|
&& (m & S_IWUSR as uint) == S_IWUSR as uint
|
|
&& (m & S_IXUSR as uint) == S_IXUSR as uint)
|
|
}
|
|
}
|
|
|
|
fn is_read_only(p: &Path) -> bool {
|
|
use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
|
|
|
|
match p.get_mode() {
|
|
None => return false,
|
|
Some(m) =>
|
|
((m & S_IRUSR as uint) == S_IRUSR as uint
|
|
&& (m & S_IWUSR as uint) == 0 as uint
|
|
&& (m & S_IXUSR as uint) == 0 as uint)
|
|
}
|
|
}
|
|
|
|
fn test_sysroot() -> Path {
|
|
// Totally gross hack but it's just for test cases.
|
|
// Infer the sysroot from the exe name and pray that it's right.
|
|
// (Did I mention it was a gross hack?)
|
|
let mut self_path = os::self_exe_path().expect("Couldn't get self_exe path");
|
|
self_path.pop();
|
|
self_path
|
|
}
|
|
|
|
// Returns the path to rustpkg
|
|
fn rustpkg_exec() -> Path {
|
|
// Ugh
|
|
let first_try = test_sysroot().join_many(
|
|
[~"lib", ~"rustc", host_triple(), ~"bin", ~"rustpkg"]);
|
|
if is_executable(&first_try) {
|
|
first_try
|
|
}
|
|
else {
|
|
let second_try = test_sysroot().join_many(["bin", "rustpkg"]);
|
|
if is_executable(&second_try) {
|
|
second_try
|
|
}
|
|
else {
|
|
fail!("in rustpkg test, can't find an installed rustpkg");
|
|
}
|
|
}
|
|
}
|
|
|
|
fn command_line_test(args: &[~str], cwd: &Path) -> ProcessOutput {
|
|
match command_line_test_with_env(args, cwd, None) {
|
|
Success(r) => r,
|
|
Fail(error) => fail!("Command line test failed with error {}", error)
|
|
}
|
|
}
|
|
|
|
fn command_line_test_partial(args: &[~str], cwd: &Path) -> ProcessResult {
|
|
command_line_test_with_env(args, cwd, None)
|
|
}
|
|
|
|
fn command_line_test_expect_fail(args: &[~str],
|
|
cwd: &Path,
|
|
env: Option<~[(~str, ~str)]>,
|
|
expected_exitcode: int) {
|
|
match command_line_test_with_env(args, cwd, env) {
|
|
Success(_) => fail!("Should have failed with {}, but it succeeded", expected_exitcode),
|
|
Fail(error) if error == expected_exitcode => (), // ok
|
|
Fail(other) => fail!("Expected to fail with {}, but failed with {} instead",
|
|
expected_exitcode, other)
|
|
}
|
|
}
|
|
|
|
enum ProcessResult {
|
|
Success(ProcessOutput),
|
|
Fail(int) // exit code
|
|
}
|
|
|
|
/// Runs `rustpkg` (based on the directory that this executable was
|
|
/// invoked from) with the given arguments, in the given working directory.
|
|
/// Returns the process's output.
|
|
fn command_line_test_with_env(args: &[~str], cwd: &Path, env: Option<~[(~str, ~str)]>)
|
|
-> ProcessResult {
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let exec_path = rustpkg_exec();
|
|
let cmd = exec_path.as_str().unwrap().to_owned();
|
|
let env_str = match env {
|
|
Some(ref pairs) => pairs.map(|&(ref k, ref v)| { format!("{}={}", *k, *v) }).connect(","),
|
|
None => ~""
|
|
};
|
|
debug!("{} cd {}; {} {}", env_str, cwd.display(), cmd, args.connect(" "));
|
|
assert!(os::path_is_dir(&*cwd));
|
|
let cwd = (*cwd).clone();
|
|
let mut prog = run::Process::new(cmd, args, run::ProcessOptions {
|
|
env: env.map(|e| e + os::env()),
|
|
dir: Some(&cwd),
|
|
in_fd: None,
|
|
out_fd: None,
|
|
err_fd: None
|
|
});
|
|
let output = prog.finish_with_output();
|
|
debug!("Output from command {} with args {:?} was {} \\{{}\\}[{:?}]",
|
|
cmd, args, str::from_utf8(output.output),
|
|
str::from_utf8(output.error),
|
|
output.status);
|
|
if output.status != 0 {
|
|
debug!("Command {} {:?} failed with exit code {:?}; its output was --- {} ---",
|
|
cmd, args, output.status,
|
|
str::from_utf8(output.output) + str::from_utf8(output.error));
|
|
Fail(output.status)
|
|
}
|
|
else {
|
|
Success(output)
|
|
}
|
|
}
|
|
|
|
fn create_local_package(pkgid: &PkgId) -> TempDir {
|
|
let (workspace, parent_dir) = mk_temp_workspace(&pkgid.path, &pkgid.version);
|
|
debug!("Created empty package dir for {}, returning {}", pkgid.to_str(), parent_dir.display());
|
|
workspace
|
|
}
|
|
|
|
fn create_local_package_in(pkgid: &PkgId, pkgdir: &Path) -> Path {
|
|
|
|
let package_dir = pkgdir.join_many([~"src", pkgid.to_str()]);
|
|
|
|
// Create main, lib, test, and bench files
|
|
assert!(os::mkdir_recursive(&package_dir, U_RWX));
|
|
debug!("Created {} and does it exist? {:?}", package_dir.display(),
|
|
os::path_is_dir(&package_dir));
|
|
// Create main, lib, test, and bench files
|
|
|
|
writeFile(&package_dir.join("main.rs"),
|
|
"fn main() { let _x = (); }");
|
|
writeFile(&package_dir.join("lib.rs"),
|
|
"pub fn f() { let _x = (); }");
|
|
writeFile(&package_dir.join("test.rs"),
|
|
"#[test] pub fn f() { (); }");
|
|
writeFile(&package_dir.join("bench.rs"),
|
|
"#[bench] pub fn f() { (); }");
|
|
package_dir
|
|
}
|
|
|
|
fn create_local_package_with_test(pkgid: &PkgId) -> TempDir {
|
|
debug!("Dry run -- would create package {:?} with test", pkgid);
|
|
create_local_package(pkgid) // Already has tests???
|
|
}
|
|
|
|
fn create_local_package_with_dep(pkgid: &PkgId, subord_pkgid: &PkgId) -> TempDir {
|
|
let package_dir = create_local_package(pkgid);
|
|
create_local_package_in(subord_pkgid, package_dir.path());
|
|
// Write a main.rs file into pkgid that references subord_pkgid
|
|
writeFile(&package_dir.path().join_many([~"src", pkgid.to_str(), ~"main.rs"]),
|
|
format!("extern mod {};\nfn main() \\{\\}",
|
|
subord_pkgid.short_name));
|
|
// Write a lib.rs file into subord_pkgid that has something in it
|
|
writeFile(&package_dir.path().join_many([~"src", subord_pkgid.to_str(), ~"lib.rs"]),
|
|
"pub fn f() {}");
|
|
package_dir
|
|
}
|
|
|
|
fn create_local_package_with_custom_build_hook(pkgid: &PkgId,
|
|
custom_build_hook: &str) -> TempDir {
|
|
debug!("Dry run -- would create package {} with custom build hook {}",
|
|
pkgid.to_str(), custom_build_hook);
|
|
create_local_package(pkgid)
|
|
// actually write the pkg.rs with the custom build hook
|
|
|
|
}
|
|
|
|
fn assert_lib_exists(repo: &Path, pkg_path: &Path, v: Version) {
|
|
assert!(lib_exists(repo, pkg_path, v));
|
|
}
|
|
|
|
fn lib_exists(repo: &Path, pkg_path: &Path, _v: Version) -> bool { // ??? version?
|
|
debug!("assert_lib_exists: repo = {}, pkg_path = {}", repo.display(), pkg_path.display());
|
|
let lib = installed_library_in_workspace(pkg_path, repo);
|
|
debug!("assert_lib_exists: checking whether {:?} exists", lib);
|
|
lib.is_some() && {
|
|
let libname = lib.get_ref();
|
|
os::path_exists(libname) && is_rwx(libname)
|
|
}
|
|
}
|
|
|
|
fn assert_executable_exists(repo: &Path, short_name: &str) {
|
|
assert!(executable_exists(repo, short_name));
|
|
}
|
|
|
|
fn executable_exists(repo: &Path, short_name: &str) -> bool {
|
|
debug!("executable_exists: repo = {}, short_name = {}", repo.display(), short_name);
|
|
let exec = target_executable_in_workspace(&PkgId::new(short_name), repo);
|
|
os::path_exists(&exec) && is_rwx(&exec)
|
|
}
|
|
|
|
fn test_executable_exists(repo: &Path, short_name: &str) -> bool {
|
|
debug!("test_executable_exists: repo = {}, short_name = {}", repo.display(), short_name);
|
|
let exec = built_test_in_workspace(&PkgId::new(short_name), repo);
|
|
do exec.map_default(false) |exec| {
|
|
os::path_exists(&exec) && is_rwx(&exec)
|
|
}
|
|
}
|
|
|
|
fn remove_executable_file(p: &PkgId, workspace: &Path) {
|
|
let exec = target_executable_in_workspace(&PkgId::new(p.short_name), workspace);
|
|
if os::path_exists(&exec) {
|
|
assert!(os::remove_file(&exec));
|
|
}
|
|
}
|
|
|
|
fn assert_built_executable_exists(repo: &Path, short_name: &str) {
|
|
assert!(built_executable_exists(repo, short_name));
|
|
}
|
|
|
|
fn built_executable_exists(repo: &Path, short_name: &str) -> bool {
|
|
debug!("assert_built_executable_exists: repo = {}, short_name = {}",
|
|
repo.display(), short_name);
|
|
let exec = built_executable_in_workspace(&PkgId::new(short_name), repo);
|
|
exec.is_some() && {
|
|
let execname = exec.get_ref();
|
|
os::path_exists(execname) && is_rwx(execname)
|
|
}
|
|
}
|
|
|
|
fn remove_built_executable_file(p: &PkgId, workspace: &Path) {
|
|
let exec = built_executable_in_workspace(&PkgId::new(p.short_name), workspace);
|
|
match exec {
|
|
Some(r) => assert!(os::remove_file(&r)),
|
|
None => ()
|
|
}
|
|
}
|
|
|
|
fn object_file_exists(repo: &Path, short_name: &str) -> bool {
|
|
file_exists(repo, short_name, "o")
|
|
}
|
|
|
|
fn assembly_file_exists(repo: &Path, short_name: &str) -> bool {
|
|
file_exists(repo, short_name, "s")
|
|
}
|
|
|
|
fn llvm_assembly_file_exists(repo: &Path, short_name: &str) -> bool {
|
|
file_exists(repo, short_name, "ll")
|
|
}
|
|
|
|
fn llvm_bitcode_file_exists(repo: &Path, short_name: &str) -> bool {
|
|
file_exists(repo, short_name, "bc")
|
|
}
|
|
|
|
fn file_exists(repo: &Path, short_name: &str, extension: &str) -> bool {
|
|
os::path_exists(&target_build_dir(repo).join_many([short_name.to_owned(),
|
|
format!("{}.{}", short_name, extension)]))
|
|
}
|
|
|
|
fn assert_built_library_exists(repo: &Path, short_name: &str) {
|
|
assert!(built_library_exists(repo, short_name));
|
|
}
|
|
|
|
fn built_library_exists(repo: &Path, short_name: &str) -> bool {
|
|
debug!("assert_built_library_exists: repo = {}, short_name = {}", repo.display(), short_name);
|
|
let lib = built_library_in_workspace(&PkgId::new(short_name), repo);
|
|
lib.is_some() && {
|
|
let libname = lib.get_ref();
|
|
os::path_exists(libname) && is_rwx(libname)
|
|
}
|
|
}
|
|
|
|
fn command_line_test_output(args: &[~str]) -> ~[~str] {
|
|
let mut result = ~[];
|
|
let p_output = command_line_test(args, &os::getcwd());
|
|
let test_output = str::from_utf8(p_output.output);
|
|
for s in test_output.split_iter('\n') {
|
|
result.push(s.to_owned());
|
|
}
|
|
result
|
|
}
|
|
|
|
fn command_line_test_output_with_env(args: &[~str], env: ~[(~str, ~str)]) -> ~[~str] {
|
|
let mut result = ~[];
|
|
let p_output = match command_line_test_with_env(args,
|
|
&os::getcwd(), Some(env)) {
|
|
Fail(_) => fail!("Command-line test failed"),
|
|
Success(r) => r
|
|
};
|
|
let test_output = str::from_utf8(p_output.output);
|
|
for s in test_output.split_iter('\n') {
|
|
result.push(s.to_owned());
|
|
}
|
|
result
|
|
}
|
|
|
|
// assumes short_name and path are one and the same -- I should fix
|
|
fn lib_output_file_name(workspace: &Path, short_name: &str) -> Path {
|
|
debug!("lib_output_file_name: given {} and short name {}",
|
|
workspace.display(), short_name);
|
|
library_in_workspace(&Path::new(short_name),
|
|
short_name,
|
|
Build,
|
|
workspace,
|
|
"build",
|
|
&NoVersion).expect("lib_output_file_name")
|
|
}
|
|
|
|
fn output_file_name(workspace: &Path, short_name: ~str) -> Path {
|
|
target_build_dir(workspace).join(short_name.as_slice()).join(format!("{}{}", short_name,
|
|
os::EXE_SUFFIX))
|
|
}
|
|
|
|
#[cfg(target_os = "linux")]
|
|
fn touch_source_file(workspace: &Path, pkgid: &PkgId) {
|
|
use conditions::bad_path::cond;
|
|
let pkg_src_dir = workspace.join_many([~"src", pkgid.to_str()]);
|
|
let contents = os::list_dir_path(&pkg_src_dir);
|
|
for p in contents.iter() {
|
|
if p.extension_str() == Some("rs") {
|
|
// should be able to do this w/o a process
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
// n.b. Bumps time up by 2 seconds to get around granularity issues
|
|
if run::process_output("touch", [~"--date",
|
|
~"+2 seconds",
|
|
p.as_str().unwrap().to_owned()]).status != 0 {
|
|
let _ = cond.raise((pkg_src_dir.clone(), ~"Bad path"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(not(target_os = "linux"))]
|
|
fn touch_source_file(workspace: &Path, pkgid: &PkgId) {
|
|
use conditions::bad_path::cond;
|
|
let pkg_src_dir = workspace.join_many([~"src", pkgid.to_str()]);
|
|
let contents = os::list_dir_path(&pkg_src_dir);
|
|
for p in contents.iter() {
|
|
if p.extension_str() == Some("rs") {
|
|
// should be able to do this w/o a process
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
// n.b. Bumps time up by 2 seconds to get around granularity issues
|
|
if run::process_output("touch", [~"-A02",
|
|
p.as_str().unwrap().to_owned()]).status != 0 {
|
|
let _ = cond.raise((pkg_src_dir.clone(), ~"Bad path"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Add a comment at the end
|
|
fn frob_source_file(workspace: &Path, pkgid: &PkgId, filename: &str) {
|
|
use conditions::bad_path::cond;
|
|
let pkg_src_dir = workspace.join_many([~"src", pkgid.to_str()]);
|
|
let mut maybe_p = None;
|
|
let maybe_file = pkg_src_dir.join(filename);
|
|
debug!("Trying to frob {} -- {}", pkg_src_dir.display(), filename);
|
|
if os::path_exists(&maybe_file) {
|
|
maybe_p = Some(maybe_file);
|
|
}
|
|
debug!("Frobbed? {:?}", maybe_p);
|
|
match maybe_p {
|
|
Some(ref p) => {
|
|
do io::io_error::cond.trap(|e| {
|
|
cond.raise((p.clone(), format!("Bad path: {}", e.desc)));
|
|
}).inside {
|
|
let mut w = p.open_writer(io::Append);
|
|
w.write(bytes!("/* hi */\n"));
|
|
}
|
|
}
|
|
None => fail!("frob_source_file failed to find a source file in {}",
|
|
pkg_src_dir.display())
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_make_dir_rwx() {
|
|
let temp = &os::tmpdir();
|
|
let dir = temp.join("quux");
|
|
assert!(!os::path_exists(&dir) ||
|
|
os::remove_dir_recursive(&dir));
|
|
debug!("Trying to make {}", dir.display());
|
|
assert!(make_dir_rwx(&dir));
|
|
assert!(os::path_is_dir(&dir));
|
|
assert!(is_rwx(&dir));
|
|
assert!(os::remove_dir_recursive(&dir));
|
|
}
|
|
|
|
// n.b. I ignored the next two tests for now because something funny happens on linux
|
|
// and I don't want to debug the issue right now (calling into the rustpkg lib directly
|
|
// is a little sketchy anyway)
|
|
#[test]
|
|
#[ignore]
|
|
fn test_install_valid() {
|
|
use path_util::installed_library_in_workspace;
|
|
|
|
let sysroot = test_sysroot();
|
|
debug!("sysroot = {}", sysroot.display());
|
|
let temp_pkg_id = fake_pkg();
|
|
let (temp_workspace, _pkg_dir) = mk_temp_workspace(&temp_pkg_id.path, &NoVersion);
|
|
let temp_workspace = temp_workspace.path();
|
|
let ctxt = fake_ctxt(sysroot, temp_workspace);
|
|
debug!("temp_workspace = {}", temp_workspace.display());
|
|
// should have test, bench, lib, and main
|
|
let src = PkgSrc::new(temp_workspace.clone(),
|
|
temp_workspace.clone(),
|
|
false,
|
|
temp_pkg_id.clone());
|
|
ctxt.install(src, &WhatToBuild::new(MaybeCustom, Everything));
|
|
// Check that all files exist
|
|
let exec = target_executable_in_workspace(&temp_pkg_id, temp_workspace);
|
|
debug!("exec = {}", exec.display());
|
|
assert!(os::path_exists(&exec));
|
|
assert!(is_rwx(&exec));
|
|
|
|
let lib = installed_library_in_workspace(&temp_pkg_id.path, temp_workspace);
|
|
debug!("lib = {:?}", lib);
|
|
assert!(lib.as_ref().map_default(false, |l| os::path_exists(l)));
|
|
assert!(lib.as_ref().map_default(false, |l| is_rwx(l)));
|
|
|
|
// And that the test and bench executables aren't installed
|
|
assert!(!os::path_exists(&target_test_in_workspace(&temp_pkg_id, temp_workspace)));
|
|
let bench = target_bench_in_workspace(&temp_pkg_id, temp_workspace);
|
|
debug!("bench = {}", bench.display());
|
|
assert!(!os::path_exists(&bench));
|
|
|
|
// Make sure the db isn't dirty, so that it doesn't try to save()
|
|
// asynchronously after the temporary directory that it wants to save
|
|
// to has been deleted.
|
|
ctxt.workcache_context.db.write(|db| db.db_dirty = false);
|
|
}
|
|
|
|
#[test]
|
|
#[ignore]
|
|
fn test_install_invalid() {
|
|
let sysroot = test_sysroot();
|
|
let pkgid = fake_pkg();
|
|
let temp_workspace = TempDir::new("test").expect("couldn't create temp dir");
|
|
let temp_workspace = temp_workspace.path().clone();
|
|
let ctxt = fake_ctxt(sysroot, &temp_workspace);
|
|
|
|
// Uses task::try because of #9001
|
|
let result = do task::try {
|
|
let pkg_src = PkgSrc::new(temp_workspace.clone(),
|
|
temp_workspace.clone(),
|
|
false,
|
|
pkgid.clone());
|
|
ctxt.install(pkg_src, &WhatToBuild::new(MaybeCustom, Everything));
|
|
};
|
|
assert!(result.unwrap_err()
|
|
.to_str().contains("supplied path for package dir does not exist"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_install_valid_external() {
|
|
let temp_pkg_id = PkgId::new("foo");
|
|
let (tempdir, _) = mk_temp_workspace(&temp_pkg_id.path,
|
|
&temp_pkg_id.version);
|
|
let temp_workspace = tempdir.path();
|
|
command_line_test([~"install", ~"foo"], temp_workspace);
|
|
|
|
// Check that all files exist
|
|
let exec = target_executable_in_workspace(&temp_pkg_id, temp_workspace);
|
|
debug!("exec = {}", exec.display());
|
|
assert!(os::path_exists(&exec));
|
|
assert!(is_rwx(&exec));
|
|
|
|
let lib = installed_library_in_workspace(&temp_pkg_id.path, temp_workspace);
|
|
debug!("lib = {:?}", lib);
|
|
assert!(lib.as_ref().map_default(false, |l| os::path_exists(l)));
|
|
assert!(lib.as_ref().map_default(false, |l| is_rwx(l)));
|
|
|
|
// And that the test and bench executables aren't installed
|
|
assert!(!os::path_exists(&target_test_in_workspace(&temp_pkg_id, temp_workspace)));
|
|
let bench = target_bench_in_workspace(&temp_pkg_id, temp_workspace);
|
|
debug!("bench = {}", bench.display());
|
|
assert!(!os::path_exists(&bench));
|
|
|
|
}
|
|
|
|
#[test]
|
|
#[ignore(reason = "9994")]
|
|
fn test_install_invalid_external() {
|
|
let cwd = os::getcwd();
|
|
command_line_test_expect_fail([~"install", ~"foo"],
|
|
&cwd,
|
|
None,
|
|
// FIXME #3408: Should be NONEXISTENT_PACKAGE_CODE
|
|
COPY_FAILED_CODE);
|
|
}
|
|
|
|
#[test]
|
|
fn test_install_git() {
|
|
let temp_pkg_id = git_repo_pkg();
|
|
let repo = init_git_repo(&temp_pkg_id.path);
|
|
let repo = repo.path();
|
|
debug!("repo = {}", repo.display());
|
|
let repo_subdir = repo.join_many(["mockgithub.com", "catamorphism", "test-pkg"]);
|
|
debug!("repo_subdir = {}", repo_subdir.display());
|
|
|
|
writeFile(&repo_subdir.join("main.rs"),
|
|
"fn main() { let _x = (); }");
|
|
writeFile(&repo_subdir.join("lib.rs"),
|
|
"pub fn f() { let _x = (); }");
|
|
writeFile(&repo_subdir.join("test.rs"),
|
|
"#[test] pub fn f() { (); }");
|
|
writeFile(&repo_subdir.join("bench.rs"),
|
|
"#[bench] pub fn f() { (); }");
|
|
add_git_tag(&repo_subdir, ~"0.1"); // this has the effect of committing the files
|
|
|
|
debug!("test_install_git: calling rustpkg install {} in {}",
|
|
temp_pkg_id.path.display(), repo.display());
|
|
// should have test, bench, lib, and main
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([~"install", temp_pkg_id.path.as_str().unwrap().to_owned()], repo);
|
|
let ws = repo.join(".rust");
|
|
// Check that all files exist
|
|
debug!("Checking for files in {}", ws.display());
|
|
let exec = target_executable_in_workspace(&temp_pkg_id, &ws);
|
|
debug!("exec = {}", exec.display());
|
|
assert!(os::path_exists(&exec));
|
|
assert!(is_rwx(&exec));
|
|
let _built_lib =
|
|
built_library_in_workspace(&temp_pkg_id,
|
|
&ws).expect("test_install_git: built lib should exist");
|
|
assert_lib_exists(&ws, &temp_pkg_id.path, temp_pkg_id.version.clone());
|
|
let built_test = built_test_in_workspace(&temp_pkg_id,
|
|
&ws).expect("test_install_git: built test should exist");
|
|
assert!(os::path_exists(&built_test));
|
|
let built_bench = built_bench_in_workspace(&temp_pkg_id,
|
|
&ws).expect("test_install_git: built bench should exist");
|
|
assert!(os::path_exists(&built_bench));
|
|
// And that the test and bench executables aren't installed
|
|
let test = target_test_in_workspace(&temp_pkg_id, &ws);
|
|
assert!(!os::path_exists(&test));
|
|
debug!("test = {}", test.display());
|
|
let bench = target_bench_in_workspace(&temp_pkg_id, &ws);
|
|
debug!("bench = {}", bench.display());
|
|
assert!(!os::path_exists(&bench));
|
|
}
|
|
|
|
#[test]
|
|
fn test_package_ids_must_be_relative_path_like() {
|
|
use conditions::bad_pkg_id::cond;
|
|
|
|
/*
|
|
Okay:
|
|
- One identifier, with no slashes
|
|
- Several slash-delimited things, with no / at the root
|
|
|
|
Not okay:
|
|
- Empty string
|
|
- Absolute path (as per os::is_absolute)
|
|
|
|
*/
|
|
|
|
let whatever = PkgId::new("foo");
|
|
|
|
assert_eq!(~"foo-0.1", whatever.to_str());
|
|
assert!("github.com/catamorphism/test-pkg-0.1" ==
|
|
PkgId::new("github.com/catamorphism/test-pkg").to_str());
|
|
|
|
do cond.trap(|(p, e)| {
|
|
assert!(p.filename().is_none())
|
|
assert!("0-length pkgid" == e);
|
|
whatever.clone()
|
|
}).inside {
|
|
let x = PkgId::new("");
|
|
assert_eq!(~"foo-0.1", x.to_str());
|
|
}
|
|
|
|
do cond.trap(|(p, e)| {
|
|
let abs = os::make_absolute(&Path::new("foo/bar/quux"));
|
|
assert_eq!(p, abs);
|
|
assert!("absolute pkgid" == e);
|
|
whatever.clone()
|
|
}).inside {
|
|
let zp = os::make_absolute(&Path::new("foo/bar/quux"));
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let z = PkgId::new(zp.as_str().unwrap());
|
|
assert_eq!(~"foo-0.1", z.to_str());
|
|
}
|
|
|
|
}
|
|
|
|
#[test]
|
|
fn test_package_version() {
|
|
let local_path = "mockgithub.com/catamorphism/test_pkg_version";
|
|
let repo = init_git_repo(&Path::new(local_path));
|
|
let repo = repo.path();
|
|
let repo_subdir = repo.join_many(["mockgithub.com", "catamorphism", "test_pkg_version"]);
|
|
debug!("Writing files in: {}", repo_subdir.display());
|
|
writeFile(&repo_subdir.join("main.rs"),
|
|
"fn main() { let _x = (); }");
|
|
writeFile(&repo_subdir.join("lib.rs"),
|
|
"pub fn f() { let _x = (); }");
|
|
writeFile(&repo_subdir.join("test.rs"),
|
|
"#[test] pub fn f() { (); }");
|
|
writeFile(&repo_subdir.join("bench.rs"),
|
|
"#[bench] pub fn f() { (); }");
|
|
add_git_tag(&repo_subdir, ~"0.4");
|
|
|
|
// It won't pick up the 0.4 version because the dir isn't in the RUST_PATH, but...
|
|
let temp_pkg_id = PkgId::new("mockgithub.com/catamorphism/test_pkg_version");
|
|
// This should look at the prefix, clone into a workspace, then build.
|
|
command_line_test([~"install", ~"mockgithub.com/catamorphism/test_pkg_version"],
|
|
repo);
|
|
let ws = repo.join(".rust");
|
|
// we can still match on the filename to make sure it contains the 0.4 version
|
|
assert!(match built_library_in_workspace(&temp_pkg_id,
|
|
&ws) {
|
|
Some(p) => {
|
|
let suffix = format!("0.4{}", os::consts::DLL_SUFFIX);
|
|
p.as_vec().ends_with(suffix.as_bytes())
|
|
}
|
|
None => false
|
|
});
|
|
assert!(built_executable_in_workspace(&temp_pkg_id, &ws)
|
|
== Some(target_build_dir(&ws).join_many(["mockgithub.com",
|
|
"catamorphism",
|
|
"test_pkg_version",
|
|
"test_pkg_version"])));
|
|
}
|
|
|
|
#[test]
|
|
fn test_package_request_version() {
|
|
let local_path = "mockgithub.com/catamorphism/test_pkg_version";
|
|
let repo = init_git_repo(&Path::new(local_path));
|
|
let repo = repo.path();
|
|
let repo_subdir = repo.join_many(["mockgithub.com", "catamorphism", "test_pkg_version"]);
|
|
debug!("Writing files in: {}", repo_subdir.display());
|
|
writeFile(&repo_subdir.join("main.rs"),
|
|
"fn main() { let _x = (); }");
|
|
writeFile(&repo_subdir.join("lib.rs"),
|
|
"pub fn f() { let _x = (); }");
|
|
writeFile(&repo_subdir.join("test.rs"),
|
|
"#[test] pub fn f() { (); }");
|
|
writeFile(&repo_subdir.join("bench.rs"),
|
|
"#[bench] pub fn f() { (); }");
|
|
writeFile(&repo_subdir.join("version-0.3-file.txt"), "hi");
|
|
add_git_tag(&repo_subdir, ~"0.3");
|
|
writeFile(&repo_subdir.join("version-0.4-file.txt"), "hello");
|
|
add_git_tag(&repo_subdir, ~"0.4");
|
|
|
|
command_line_test([~"install", format!("{}\\#0.3", local_path)], repo);
|
|
|
|
assert!(match installed_library_in_workspace(&Path::new("test_pkg_version"),
|
|
&repo.join(".rust")) {
|
|
Some(p) => {
|
|
debug!("installed: {}", p.display());
|
|
let suffix = format!("0.3{}", os::consts::DLL_SUFFIX);
|
|
p.as_vec().ends_with(suffix.as_bytes())
|
|
}
|
|
None => false
|
|
});
|
|
let temp_pkg_id = PkgId::new("mockgithub.com/catamorphism/test_pkg_version#0.3");
|
|
assert!(target_executable_in_workspace(&temp_pkg_id, &repo.join(".rust"))
|
|
== repo.join_many([".rust", "bin", "test_pkg_version"]));
|
|
|
|
let mut dir = target_build_dir(&repo.join(".rust"));
|
|
dir.push(&Path::new("src/mockgithub.com/catamorphism/test_pkg_version-0.3"));
|
|
debug!("dir = {}", dir.display());
|
|
assert!(os::path_is_dir(&dir));
|
|
assert!(os::path_exists(&dir.join("version-0.3-file.txt")));
|
|
assert!(!os::path_exists(&dir.join("version-0.4-file.txt")));
|
|
}
|
|
|
|
#[test]
|
|
#[ignore (reason = "http-client not ported to rustpkg yet")]
|
|
fn rustpkg_install_url_2() {
|
|
let temp_dir = TempDir::new("rustpkg_install_url_2").expect("rustpkg_install_url_2");
|
|
command_line_test([~"install", ~"github.com/mozilla-servo/rust-http-client"],
|
|
temp_dir.path());
|
|
}
|
|
|
|
#[test]
|
|
fn rustpkg_library_target() {
|
|
let foo_repo = init_git_repo(&Path::new("foo"));
|
|
let foo_repo = foo_repo.path();
|
|
let package_dir = foo_repo.join("foo");
|
|
|
|
debug!("Writing files in: {}", package_dir.display());
|
|
writeFile(&package_dir.join("main.rs"),
|
|
"fn main() { let _x = (); }");
|
|
writeFile(&package_dir.join("lib.rs"),
|
|
"pub fn f() { let _x = (); }");
|
|
writeFile(&package_dir.join("test.rs"),
|
|
"#[test] pub fn f() { (); }");
|
|
writeFile(&package_dir.join("bench.rs"),
|
|
"#[bench] pub fn f() { (); }");
|
|
|
|
add_git_tag(&package_dir, ~"1.0");
|
|
command_line_test([~"install", ~"foo"], foo_repo);
|
|
assert_lib_exists(&foo_repo.join(".rust"), &Path::new("foo"), ExactRevision(~"1.0"));
|
|
}
|
|
|
|
#[test]
|
|
fn rustpkg_local_pkg() {
|
|
let dir = create_local_package(&PkgId::new("foo"));
|
|
command_line_test([~"install", ~"foo"], dir.path());
|
|
assert_executable_exists(dir.path(), "foo");
|
|
}
|
|
|
|
#[test]
|
|
fn package_script_with_default_build() {
|
|
let dir = create_local_package(&PkgId::new("fancy-lib"));
|
|
let dir = dir.path();
|
|
debug!("dir = {}", dir.display());
|
|
let mut source = test_sysroot().dir_path();
|
|
source.pop(); source.pop();
|
|
let source = Path::new(file!()).dir_path().join_many(
|
|
[~"testsuite", ~"pass", ~"src", ~"fancy-lib", ~"pkg.rs"]);
|
|
debug!("package_script_with_default_build: {}", source.display());
|
|
if !os::copy_file(&source,
|
|
&dir.join_many(["src", "fancy-lib-0.1", "pkg.rs"])) {
|
|
fail!("Couldn't copy file");
|
|
}
|
|
command_line_test([~"install", ~"fancy-lib"], dir);
|
|
assert_lib_exists(dir, &Path::new("fancy-lib"), NoVersion);
|
|
assert!(os::path_exists(&target_build_dir(dir).join_many([~"fancy-lib", ~"generated.rs"])));
|
|
let generated_path = target_build_dir(dir).join_many([~"fancy-lib", ~"generated.rs"]);
|
|
debug!("generated path = {}", generated_path.display());
|
|
assert!(os::path_exists(&generated_path));
|
|
}
|
|
|
|
#[test]
|
|
fn rustpkg_build_no_arg() {
|
|
let tmp = TempDir::new("rustpkg_build_no_arg").expect("rustpkg_build_no_arg failed");
|
|
let tmp = tmp.path().join(".rust");
|
|
let package_dir = tmp.join_many(["src", "foo"]);
|
|
assert!(os::mkdir_recursive(&package_dir, U_RWX));
|
|
|
|
writeFile(&package_dir.join("main.rs"),
|
|
"fn main() { let _x = (); }");
|
|
debug!("build_no_arg: dir = {}", package_dir.display());
|
|
command_line_test([~"build"], &package_dir);
|
|
assert_built_executable_exists(&tmp, "foo");
|
|
}
|
|
|
|
#[test]
|
|
fn rustpkg_install_no_arg() {
|
|
let tmp = TempDir::new("rustpkg_install_no_arg").expect("rustpkg_install_no_arg failed");
|
|
let tmp = tmp.path().join(".rust");
|
|
let package_dir = tmp.join_many(["src", "foo"]);
|
|
assert!(os::mkdir_recursive(&package_dir, U_RWX));
|
|
writeFile(&package_dir.join("lib.rs"),
|
|
"fn main() { let _x = (); }");
|
|
debug!("install_no_arg: dir = {}", package_dir.display());
|
|
command_line_test([~"install"], &package_dir);
|
|
assert_lib_exists(&tmp, &Path::new("foo"), NoVersion);
|
|
}
|
|
|
|
#[test]
|
|
fn rustpkg_clean_no_arg() {
|
|
let tmp = TempDir::new("rustpkg_clean_no_arg").expect("rustpkg_clean_no_arg failed");
|
|
let tmp = tmp.path().join(".rust");
|
|
let package_dir = tmp.join_many(["src", "foo"]);
|
|
assert!(os::mkdir_recursive(&package_dir, U_RWX));
|
|
|
|
writeFile(&package_dir.join("main.rs"),
|
|
"fn main() { let _x = (); }");
|
|
debug!("clean_no_arg: dir = {}", package_dir.display());
|
|
command_line_test([~"build"], &package_dir);
|
|
assert_built_executable_exists(&tmp, "foo");
|
|
command_line_test([~"clean"], &package_dir);
|
|
let res = built_executable_in_workspace(&PkgId::new("foo"), &tmp);
|
|
assert!(!res.as_ref().map_default(false, |m| { os::path_exists(m) }));
|
|
}
|
|
|
|
#[test]
|
|
fn rust_path_test() {
|
|
let dir_for_path = TempDir::new("more_rust").expect("rust_path_test failed");
|
|
let dir = mk_workspace(dir_for_path.path(), &Path::new("foo"), &NoVersion);
|
|
debug!("dir = {}", dir.display());
|
|
writeFile(&dir.join("main.rs"), "fn main() { let _x = (); }");
|
|
|
|
let cwd = os::getcwd();
|
|
debug!("cwd = {}", cwd.display());
|
|
// use command_line_test_with_env
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test_with_env([~"install", ~"foo"],
|
|
&cwd,
|
|
Some(~[(~"RUST_PATH",
|
|
dir_for_path.path().as_str().unwrap().to_owned())]));
|
|
assert_executable_exists(dir_for_path.path(), "foo");
|
|
}
|
|
|
|
#[test]
|
|
#[ignore] // FIXME(#9184) tests can't change the cwd (other tests are sad then)
|
|
fn rust_path_contents() {
|
|
let dir = TempDir::new("rust_path").expect("rust_path_contents failed");
|
|
let abc = &dir.path().join_many(["A", "B", "C"]);
|
|
assert!(os::mkdir_recursive(&abc.join(".rust"), U_RWX));
|
|
assert!(os::mkdir_recursive(&abc.with_filename(".rust"), U_RWX));
|
|
assert!(os::mkdir_recursive(&abc.dir_path().with_filename(".rust"), U_RWX));
|
|
assert!(os::change_dir(abc));
|
|
|
|
let p = rust_path();
|
|
let cwd = os::getcwd().join(".rust");
|
|
let parent = cwd.dir_path().with_filename(".rust");
|
|
let grandparent = cwd.dir_path().dir_path().with_filename(".rust");
|
|
assert!(p.contains(&cwd));
|
|
assert!(p.contains(&parent));
|
|
assert!(p.contains(&grandparent));
|
|
for a_path in p.iter() {
|
|
assert!(a_path.filename().is_some());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn rust_path_parse() {
|
|
os::setenv("RUST_PATH", "/a/b/c:/d/e/f:/g/h/i");
|
|
let paths = rust_path();
|
|
assert!(paths.contains(&Path::new("/g/h/i")));
|
|
assert!(paths.contains(&Path::new("/d/e/f")));
|
|
assert!(paths.contains(&Path::new("/a/b/c")));
|
|
os::unsetenv("RUST_PATH");
|
|
}
|
|
|
|
#[test]
|
|
fn test_list() {
|
|
let dir = TempDir::new("test_list").expect("test_list failed");
|
|
let dir = dir.path();
|
|
let foo = PkgId::new("foo");
|
|
create_local_package_in(&foo, dir);
|
|
let bar = PkgId::new("bar");
|
|
create_local_package_in(&bar, dir);
|
|
let quux = PkgId::new("quux");
|
|
create_local_package_in(&quux, dir);
|
|
|
|
// list doesn't output very much right now...
|
|
command_line_test([~"install", ~"foo"], dir);
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let env_arg = ~[(~"RUST_PATH", dir.as_str().unwrap().to_owned())];
|
|
let list_output = command_line_test_output_with_env([~"list"], env_arg.clone());
|
|
assert!(list_output.iter().any(|x| x.starts_with("foo")));
|
|
|
|
command_line_test([~"install", ~"bar"], dir);
|
|
let list_output = command_line_test_output_with_env([~"list"], env_arg.clone());
|
|
assert!(list_output.iter().any(|x| x.starts_with("foo")));
|
|
assert!(list_output.iter().any(|x| x.starts_with("bar")));
|
|
|
|
command_line_test([~"install", ~"quux"], dir);
|
|
let list_output = command_line_test_output_with_env([~"list"], env_arg);
|
|
assert!(list_output.iter().any(|x| x.starts_with("foo")));
|
|
assert!(list_output.iter().any(|x| x.starts_with("bar")));
|
|
assert!(list_output.iter().any(|x| x.starts_with("quux")));
|
|
}
|
|
|
|
#[test]
|
|
fn install_remove() {
|
|
let dir = TempDir::new("install_remove").expect("install_remove");
|
|
let dir = dir.path();
|
|
let foo = PkgId::new("foo");
|
|
let bar = PkgId::new("bar");
|
|
let quux = PkgId::new("quux");
|
|
create_local_package_in(&foo, dir);
|
|
create_local_package_in(&bar, dir);
|
|
create_local_package_in(&quux, dir);
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let rust_path_to_use = ~[(~"RUST_PATH", dir.as_str().unwrap().to_owned())];
|
|
command_line_test([~"install", ~"foo"], dir);
|
|
command_line_test([~"install", ~"bar"], dir);
|
|
command_line_test([~"install", ~"quux"], dir);
|
|
let list_output = command_line_test_output_with_env([~"list"], rust_path_to_use.clone());
|
|
assert!(list_output.iter().any(|x| x.starts_with("foo")));
|
|
assert!(list_output.iter().any(|x| x.starts_with("bar")));
|
|
assert!(list_output.iter().any(|x| x.starts_with("quux")));
|
|
command_line_test([~"uninstall", ~"foo"], dir);
|
|
let list_output = command_line_test_output_with_env([~"list"], rust_path_to_use.clone());
|
|
assert!(!list_output.iter().any(|x| x.starts_with("foo")));
|
|
assert!(list_output.iter().any(|x| x.starts_with("bar")));
|
|
assert!(list_output.iter().any(|x| x.starts_with("quux")));
|
|
}
|
|
|
|
#[test]
|
|
fn install_check_duplicates() {
|
|
// should check that we don't install two packages with the same full name *and* version
|
|
// ("Is already installed -- doing nothing")
|
|
// check invariant that there are no dups in the pkg database
|
|
let dir = TempDir::new("install_remove").expect("install_remove");
|
|
let dir = dir.path();
|
|
let foo = PkgId::new("foo");
|
|
create_local_package_in(&foo, dir);
|
|
|
|
command_line_test([~"install", ~"foo"], dir);
|
|
command_line_test([~"install", ~"foo"], dir);
|
|
let mut contents = ~[];
|
|
let check_dups = |p: &PkgId| {
|
|
if contents.contains(p) {
|
|
fail!("package {} appears in `list` output more than once", p.path.display());
|
|
}
|
|
else {
|
|
contents.push((*p).clone());
|
|
}
|
|
true
|
|
};
|
|
list_installed_packages(check_dups);
|
|
}
|
|
|
|
#[test]
|
|
fn no_rebuilding() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
command_line_test([~"build", ~"foo"], workspace);
|
|
let foo_lib = lib_output_file_name(workspace, "foo");
|
|
// Now make `foo` read-only so that subsequent rebuilds of it will fail
|
|
assert!(chmod_read_only(&foo_lib));
|
|
|
|
command_line_test([~"build", ~"foo"], workspace);
|
|
|
|
match command_line_test_partial([~"build", ~"foo"], workspace) {
|
|
Success(*) => (), // ok
|
|
Fail(status) if status == 65 => fail!("no_rebuilding failed: it tried to rebuild bar"),
|
|
Fail(_) => fail!("no_rebuilding failed for some other reason")
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn no_rebuilding_dep() {
|
|
let p_id = PkgId::new("foo");
|
|
let dep_id = PkgId::new("bar");
|
|
let workspace = create_local_package_with_dep(&p_id, &dep_id);
|
|
let workspace = workspace.path();
|
|
command_line_test([~"build", ~"foo"], workspace);
|
|
let bar_lib = lib_output_file_name(workspace, "bar");
|
|
frob_source_file(workspace, &p_id, "main.rs");
|
|
// Now make `bar` read-only so that subsequent rebuilds of it will fail
|
|
assert!(chmod_read_only(&bar_lib));
|
|
match command_line_test_partial([~"build", ~"foo"], workspace) {
|
|
Success(*) => (), // ok
|
|
Fail(status) if status == 65 => fail!("no_rebuilding_dep failed: it tried to rebuild bar"),
|
|
Fail(_) => fail!("no_rebuilding_dep failed for some other reason")
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn do_rebuild_dep_dates_change() {
|
|
let p_id = PkgId::new("foo");
|
|
let dep_id = PkgId::new("bar");
|
|
let workspace = create_local_package_with_dep(&p_id, &dep_id);
|
|
let workspace = workspace.path();
|
|
command_line_test([~"build", ~"foo"], workspace);
|
|
let bar_lib_name = lib_output_file_name(workspace, "bar");
|
|
touch_source_file(workspace, &dep_id);
|
|
|
|
// Now make `bar` read-only so that subsequent rebuilds of it will fail
|
|
assert!(chmod_read_only(&bar_lib_name));
|
|
|
|
match command_line_test_partial([~"build", ~"foo"], workspace) {
|
|
Success(*) => fail!("do_rebuild_dep_dates_change failed: it didn't rebuild bar"),
|
|
Fail(status) if status == 65 => (), // ok
|
|
Fail(_) => fail!("do_rebuild_dep_dates_change failed for some other reason")
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn do_rebuild_dep_only_contents_change() {
|
|
let p_id = PkgId::new("foo");
|
|
let dep_id = PkgId::new("bar");
|
|
let workspace = create_local_package_with_dep(&p_id, &dep_id);
|
|
let workspace = workspace.path();
|
|
command_line_test([~"build", ~"foo"], workspace);
|
|
frob_source_file(workspace, &dep_id, "lib.rs");
|
|
let bar_lib_name = lib_output_file_name(workspace, "bar");
|
|
|
|
// Now make `bar` read-only so that subsequent rebuilds of it will fail
|
|
assert!(chmod_read_only(&bar_lib_name));
|
|
|
|
// should adjust the datestamp
|
|
match command_line_test_partial([~"build", ~"foo"], workspace) {
|
|
Success(*) => fail!("do_rebuild_dep_only_contents_change failed: it didn't rebuild bar"),
|
|
Fail(status) if status == 65 => (), // ok
|
|
Fail(_) => fail!("do_rebuild_dep_only_contents_change failed for some other reason")
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_versions() {
|
|
let workspace = create_local_package(&PkgId::new("foo#0.1"));
|
|
let _other_workspace = create_local_package(&PkgId::new("foo#0.2"));
|
|
command_line_test([~"install", ~"foo#0.1"], workspace.path());
|
|
let output = command_line_test_output([~"list"]);
|
|
// make sure output includes versions
|
|
assert!(!output.iter().any(|x| x == &~"foo#0.2"));
|
|
}
|
|
|
|
#[test]
|
|
#[ignore(reason = "do not yet implemented")]
|
|
fn test_build_hooks() {
|
|
let workspace = create_local_package_with_custom_build_hook(&PkgId::new("foo"),
|
|
"frob");
|
|
command_line_test([~"do", ~"foo", ~"frob"], workspace.path());
|
|
}
|
|
|
|
|
|
#[test]
|
|
#[ignore(reason = "info not yet implemented")]
|
|
fn test_info() {
|
|
let expected_info = ~"package foo"; // fill in
|
|
let workspace = create_local_package(&PkgId::new("foo"));
|
|
let output = command_line_test([~"info", ~"foo"], workspace.path());
|
|
assert_eq!(str::from_utf8(output.output), expected_info);
|
|
}
|
|
|
|
#[test]
|
|
fn test_uninstall() {
|
|
let workspace = create_local_package(&PkgId::new("foo"));
|
|
command_line_test([~"uninstall", ~"foo"], workspace.path());
|
|
let output = command_line_test([~"list"], workspace.path());
|
|
assert!(!str::from_utf8(output.output).contains("foo"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_non_numeric_tag() {
|
|
let temp_pkg_id = git_repo_pkg();
|
|
let repo = init_git_repo(&temp_pkg_id.path);
|
|
let repo = repo.path();
|
|
let repo_subdir = repo.join_many(["mockgithub.com", "catamorphism", "test-pkg"]);
|
|
writeFile(&repo_subdir.join("foo"), "foo");
|
|
writeFile(&repo_subdir.join("lib.rs"),
|
|
"pub fn f() { let _x = (); }");
|
|
add_git_tag(&repo_subdir, ~"testbranch");
|
|
writeFile(&repo_subdir.join("testbranch_only"), "hello");
|
|
add_git_tag(&repo_subdir, ~"another_tag");
|
|
writeFile(&repo_subdir.join("not_on_testbranch_only"), "bye bye");
|
|
add_all_and_commit(&repo_subdir);
|
|
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([~"install", format!("{}\\#testbranch",
|
|
temp_pkg_id.path.as_str().unwrap())], repo);
|
|
let file1 = repo.join_many(["mockgithub.com", "catamorphism", "test-pkg", "testbranch_only"]);
|
|
let file2 = repo.join_many(["mockgithub.com", "catamorphism", "test-pkg", "master_only"]);
|
|
assert!(os::path_exists(&file1));
|
|
assert!(!os::path_exists(&file2));
|
|
}
|
|
|
|
#[test]
|
|
fn test_extern_mod() {
|
|
let dir = TempDir::new("test_extern_mod").expect("test_extern_mod");
|
|
let dir = dir.path();
|
|
let main_file = dir.join("main.rs");
|
|
let lib_depend_dir = TempDir::new("foo").expect("test_extern_mod");
|
|
let lib_depend_dir = lib_depend_dir.path();
|
|
let aux_dir = lib_depend_dir.join_many(["src", "mockgithub.com", "catamorphism", "test_pkg"]);
|
|
assert!(os::mkdir_recursive(&aux_dir, U_RWX));
|
|
let aux_pkg_file = aux_dir.join("lib.rs");
|
|
|
|
writeFile(&aux_pkg_file, "pub mod bar { pub fn assert_true() { assert!(true); } }\n");
|
|
assert!(os::path_exists(&aux_pkg_file));
|
|
|
|
writeFile(&main_file,
|
|
"extern mod test = \"mockgithub.com/catamorphism/test_pkg\";\nuse test::bar;\
|
|
fn main() { bar::assert_true(); }\n");
|
|
|
|
command_line_test([~"install", ~"mockgithub.com/catamorphism/test_pkg"], lib_depend_dir);
|
|
|
|
let exec_file = dir.join("out");
|
|
// Be sure to extend the existing environment
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let env = Some([(~"RUST_PATH", lib_depend_dir.as_str().unwrap().to_owned())] + os::env());
|
|
let rustpkg_exec = rustpkg_exec();
|
|
let rustc = rustpkg_exec.with_filename("rustc");
|
|
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let mut prog = run::Process::new(rustc.as_str().unwrap(),
|
|
[main_file.as_str().unwrap().to_owned(),
|
|
~"--sysroot", test_sys.as_str().unwrap().to_owned(),
|
|
~"-o", exec_file.as_str().unwrap().to_owned()],
|
|
run::ProcessOptions {
|
|
env: env,
|
|
dir: Some(dir),
|
|
in_fd: None,
|
|
out_fd: None,
|
|
err_fd: None
|
|
});
|
|
let outp = prog.finish_with_output();
|
|
if outp.status != 0 {
|
|
fail!("output was {}, error was {}",
|
|
str::from_utf8(outp.output),
|
|
str::from_utf8(outp.error));
|
|
}
|
|
assert!(os::path_exists(&exec_file) && is_executable(&exec_file));
|
|
}
|
|
|
|
#[test]
|
|
fn test_extern_mod_simpler() {
|
|
let dir = TempDir::new("test_extern_mod_simpler").expect("test_extern_mod_simpler");
|
|
let dir = dir.path();
|
|
let main_file = dir.join("main.rs");
|
|
let lib_depend_dir = TempDir::new("foo").expect("test_extern_mod_simpler");
|
|
let lib_depend_dir = lib_depend_dir.path();
|
|
let aux_dir = lib_depend_dir.join_many(["src", "rust-awesomeness"]);
|
|
assert!(os::mkdir_recursive(&aux_dir, U_RWX));
|
|
let aux_pkg_file = aux_dir.join("lib.rs");
|
|
|
|
writeFile(&aux_pkg_file, "pub mod bar { pub fn assert_true() { assert!(true); } }\n");
|
|
assert!(os::path_exists(&aux_pkg_file));
|
|
|
|
writeFile(&main_file,
|
|
"extern mod test = \"rust-awesomeness\";\nuse test::bar;\
|
|
fn main() { bar::assert_true(); }\n");
|
|
|
|
command_line_test([~"install", ~"rust-awesomeness"], lib_depend_dir);
|
|
|
|
let exec_file = dir.join("out");
|
|
// Be sure to extend the existing environment
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let env = Some([(~"RUST_PATH", lib_depend_dir.as_str().unwrap().to_owned())] + os::env());
|
|
let rustpkg_exec = rustpkg_exec();
|
|
let rustc = rustpkg_exec.with_filename("rustc");
|
|
let test_sys = test_sysroot();
|
|
debug!("RUST_PATH={} {} {} \n --sysroot {} -o {}",
|
|
lib_depend_dir.display(),
|
|
rustc.display(),
|
|
main_file.display(),
|
|
test_sys.display(),
|
|
exec_file.display());
|
|
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let mut prog = run::Process::new(rustc.as_str().unwrap(),
|
|
[main_file.as_str().unwrap().to_owned(),
|
|
~"--sysroot", test_sys.as_str().unwrap().to_owned(),
|
|
~"-o", exec_file.as_str().unwrap().to_owned()],
|
|
run::ProcessOptions {
|
|
env: env,
|
|
dir: Some(dir),
|
|
in_fd: None,
|
|
out_fd: None,
|
|
err_fd: None
|
|
});
|
|
let outp = prog.finish_with_output();
|
|
if outp.status != 0 {
|
|
fail!("output was {}, error was {}",
|
|
str::from_utf8(outp.output),
|
|
str::from_utf8(outp.error));
|
|
}
|
|
assert!(os::path_exists(&exec_file) && is_executable(&exec_file));
|
|
}
|
|
|
|
#[test]
|
|
fn test_import_rustpkg() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
writeFile(&workspace.join_many(["src", "foo-0.1", "pkg.rs"]),
|
|
"extern mod rustpkg; fn main() {}");
|
|
command_line_test([~"build", ~"foo"], workspace);
|
|
debug!("workspace = {}", workspace.display());
|
|
assert!(os::path_exists(&target_build_dir(workspace).join("foo").join(format!("pkg{}",
|
|
os::EXE_SUFFIX))));
|
|
}
|
|
|
|
#[test]
|
|
fn test_macro_pkg_script() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
writeFile(&workspace.join_many(["src", "foo-0.1", "pkg.rs"]),
|
|
"extern mod rustpkg; fn main() { debug!(\"Hi\"); }");
|
|
command_line_test([~"build", ~"foo"], workspace);
|
|
debug!("workspace = {}", workspace.display());
|
|
assert!(os::path_exists(&target_build_dir(workspace).join("foo").join(format!("pkg{}",
|
|
os::EXE_SUFFIX))));
|
|
}
|
|
|
|
#[test]
|
|
fn multiple_workspaces() {
|
|
// Make a package foo; build/install in directory A
|
|
// Copy the exact same package into directory B and install it
|
|
// Set the RUST_PATH to A:B
|
|
// Make a third package that uses foo, make sure we can build/install it
|
|
let (a_loc, _pkg_dir) = mk_temp_workspace(&Path::new("foo"), &NoVersion);
|
|
let (b_loc, _pkg_dir) = mk_temp_workspace(&Path::new("foo"), &NoVersion);
|
|
let (a_loc, b_loc) = (a_loc.path(), b_loc.path());
|
|
debug!("Trying to install foo in {}", a_loc.display());
|
|
command_line_test([~"install", ~"foo"], a_loc);
|
|
debug!("Trying to install foo in {}", b_loc.display());
|
|
command_line_test([~"install", ~"foo"], b_loc);
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let env = Some(~[(~"RUST_PATH", format!("{}:{}", a_loc.as_str().unwrap(),
|
|
b_loc.as_str().unwrap()))]);
|
|
let c_loc = create_local_package_with_dep(&PkgId::new("bar"), &PkgId::new("foo"));
|
|
command_line_test_with_env([~"install", ~"bar"], c_loc.path(), env);
|
|
}
|
|
|
|
fn rust_path_hack_test(hack_flag: bool) {
|
|
/*
|
|
Make a workspace containing a pkg foo [A]
|
|
Make a second, empty workspace [B]
|
|
Set RUST_PATH to B:A
|
|
rustpkg install foo
|
|
make sure built files for foo are in B
|
|
make sure nothing gets built into A or A/../build[lib,bin]
|
|
*/
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
let dest_workspace = mk_empty_workspace(&Path::new("bar"), &NoVersion, "dest_workspace");
|
|
let dest_workspace = dest_workspace.path();
|
|
let foo_path = workspace.join_many(["src", "foo-0.1"]);
|
|
let rust_path = Some(~[(~"RUST_PATH",
|
|
format!("{}:{}",
|
|
dest_workspace.as_str().unwrap(),
|
|
foo_path.as_str().unwrap()))]);
|
|
command_line_test_with_env(~[~"install"] + if hack_flag { ~[~"--rust-path-hack"] } else { ~[] } +
|
|
~[~"foo"], dest_workspace, rust_path);
|
|
assert_lib_exists(dest_workspace, &Path::new("foo"), NoVersion);
|
|
assert_executable_exists(dest_workspace, "foo");
|
|
assert_built_library_exists(dest_workspace, "foo");
|
|
assert_built_executable_exists(dest_workspace, "foo");
|
|
assert!(!lib_exists(workspace, &Path::new("foo"), NoVersion));
|
|
assert!(!executable_exists(workspace, "foo"));
|
|
assert!(!built_library_exists(workspace, "foo"));
|
|
assert!(!built_executable_exists(workspace, "foo"));
|
|
}
|
|
|
|
// Notice that this is the only test case where the --rust-path-hack
|
|
// flag is actually needed
|
|
#[test]
|
|
fn test_rust_path_can_contain_package_dirs_with_flag() {
|
|
/*
|
|
Test that the temporary hack added for bootstrapping Servo builds
|
|
works. That is: if you add $FOO/src/some_pkg to the RUST_PATH,
|
|
it will find the sources in some_pkg, build them, and install them
|
|
into the first entry in the RUST_PATH.
|
|
|
|
When the hack is removed, we should change this to a should_fail test.
|
|
*/
|
|
rust_path_hack_test(true);
|
|
}
|
|
|
|
#[test]
|
|
#[should_fail]
|
|
fn test_rust_path_can_contain_package_dirs_without_flag() {
|
|
rust_path_hack_test(false);
|
|
}
|
|
|
|
#[test]
|
|
fn rust_path_hack_cwd() {
|
|
// Same as rust_path_hack_test, but the CWD is the dir to build out of
|
|
let cwd = TempDir::new("foo").expect("rust_path_hack_cwd");
|
|
let cwd = cwd.path().join("foo");
|
|
assert!(os::mkdir_recursive(&cwd, U_RWX));
|
|
writeFile(&cwd.join("lib.rs"), "pub fn f() { }");
|
|
|
|
let dest_workspace = mk_empty_workspace(&Path::new("bar"), &NoVersion, "dest_workspace");
|
|
let dest_workspace = dest_workspace.path();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let rust_path = Some(~[(~"RUST_PATH", dest_workspace.as_str().unwrap().to_owned())]);
|
|
command_line_test_with_env([~"install", ~"--rust-path-hack", ~"foo"], &cwd, rust_path);
|
|
debug!("Checking that foo exists in {}", dest_workspace.display());
|
|
assert_lib_exists(dest_workspace, &Path::new("foo"), NoVersion);
|
|
assert_built_library_exists(dest_workspace, "foo");
|
|
assert!(!lib_exists(&cwd, &Path::new("foo"), NoVersion));
|
|
assert!(!built_library_exists(&cwd, "foo"));
|
|
}
|
|
|
|
#[test]
|
|
fn rust_path_hack_multi_path() {
|
|
// Same as rust_path_hack_test, but with a more complex package ID
|
|
let cwd = TempDir::new("pkg_files").expect("rust_path_hack_cwd");
|
|
let subdir = cwd.path().join_many(["foo", "bar", "quux"]);
|
|
assert!(os::mkdir_recursive(&subdir, U_RWX));
|
|
writeFile(&subdir.join("lib.rs"), "pub fn f() { }");
|
|
let name = ~"foo/bar/quux";
|
|
|
|
let dest_workspace = mk_empty_workspace(&Path::new("bar"), &NoVersion, "dest_workspace");
|
|
let dest_workspace = dest_workspace.path();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let rust_path = Some(~[(~"RUST_PATH", dest_workspace.as_str().unwrap().to_owned())]);
|
|
command_line_test_with_env([~"install", ~"--rust-path-hack", name.clone()], &subdir, rust_path);
|
|
debug!("Checking that {} exists in {}", name, dest_workspace.display());
|
|
assert_lib_exists(dest_workspace, &Path::new("quux"), NoVersion);
|
|
assert_built_library_exists(dest_workspace, name);
|
|
assert!(!lib_exists(&subdir, &Path::new("quux"), NoVersion));
|
|
assert!(!built_library_exists(&subdir, name));
|
|
}
|
|
|
|
#[test]
|
|
fn rust_path_hack_install_no_arg() {
|
|
// Same as rust_path_hack_cwd, but making rustpkg infer the pkg id
|
|
let cwd = TempDir::new("pkg_files").expect("rust_path_hack_install_no_arg");
|
|
let cwd = cwd.path();
|
|
let source_dir = cwd.join("foo");
|
|
assert!(make_dir_rwx(&source_dir));
|
|
writeFile(&source_dir.join("lib.rs"), "pub fn f() { }");
|
|
|
|
let dest_workspace = mk_empty_workspace(&Path::new("bar"), &NoVersion, "dest_workspace");
|
|
let dest_workspace = dest_workspace.path();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let rust_path = Some(~[(~"RUST_PATH", dest_workspace.as_str().unwrap().to_owned())]);
|
|
command_line_test_with_env([~"install", ~"--rust-path-hack"], &source_dir, rust_path);
|
|
debug!("Checking that foo exists in {}", dest_workspace.display());
|
|
assert_lib_exists(dest_workspace, &Path::new("foo"), NoVersion);
|
|
assert_built_library_exists(dest_workspace, "foo");
|
|
assert!(!lib_exists(&source_dir, &Path::new("foo"), NoVersion));
|
|
assert!(!built_library_exists(cwd, "foo"));
|
|
}
|
|
|
|
#[test]
|
|
fn rust_path_hack_build_no_arg() {
|
|
// Same as rust_path_hack_install_no_arg, but building instead of installing
|
|
let cwd = TempDir::new("pkg_files").expect("rust_path_hack_build_no_arg");
|
|
let source_dir = cwd.path().join("foo");
|
|
assert!(make_dir_rwx(&source_dir));
|
|
writeFile(&source_dir.join("lib.rs"), "pub fn f() { }");
|
|
|
|
let dest_workspace = mk_empty_workspace(&Path::new("bar"), &NoVersion, "dest_workspace");
|
|
let dest_workspace = dest_workspace.path();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let rust_path = Some(~[(~"RUST_PATH", dest_workspace.as_str().unwrap().to_owned())]);
|
|
command_line_test_with_env([~"build", ~"--rust-path-hack"], &source_dir, rust_path);
|
|
debug!("Checking that foo exists in {}", dest_workspace.display());
|
|
assert_built_library_exists(dest_workspace, "foo");
|
|
assert!(!built_library_exists(&source_dir, "foo"));
|
|
}
|
|
|
|
#[test]
|
|
fn rust_path_hack_build_with_dependency() {
|
|
let foo_id = PkgId::new("foo");
|
|
let dep_id = PkgId::new("dep");
|
|
// Tests that when --rust-path-hack is in effect, dependencies get built
|
|
// into the destination workspace and not the source directory
|
|
let work_dir = create_local_package(&foo_id);
|
|
let work_dir = work_dir.path();
|
|
let dep_workspace = create_local_package(&dep_id);
|
|
let dep_workspace = dep_workspace.path();
|
|
let dest_workspace = mk_emptier_workspace("dep");
|
|
let dest_workspace = dest_workspace.path();
|
|
let source_dir = work_dir.join_many(["src", "foo-0.1"]);
|
|
writeFile(&source_dir.join("lib.rs"), "extern mod dep; pub fn f() { }");
|
|
let dep_dir = dep_workspace.join_many(["src", "dep-0.1"]);
|
|
let rust_path = Some(~[(~"RUST_PATH",
|
|
format!("{}:{}",
|
|
dest_workspace.display(),
|
|
dep_dir.display()))]);
|
|
command_line_test_with_env([~"build", ~"--rust-path-hack", ~"foo"], work_dir, rust_path);
|
|
assert_built_library_exists(dest_workspace, "dep");
|
|
assert!(!built_library_exists(dep_workspace, "dep"));
|
|
}
|
|
|
|
#[test]
|
|
fn rust_path_install_target() {
|
|
let dir_for_path = TempDir::new(
|
|
"source_workspace").expect("rust_path_install_target failed");
|
|
let mut dir = mk_workspace(dir_for_path.path(), &Path::new("foo"), &NoVersion);
|
|
debug!("dir = {}", dir.display());
|
|
writeFile(&dir.join("main.rs"), "fn main() { let _x = (); }");
|
|
let dir_to_install_to = TempDir::new(
|
|
"dest_workspace").expect("rust_path_install_target failed");
|
|
let dir_to_install_to = dir_to_install_to.path();
|
|
dir.pop(); dir.pop();
|
|
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let rust_path = Some(~[(~"RUST_PATH", format!("{}:{}",
|
|
dir_to_install_to.as_str().unwrap(),
|
|
dir.as_str().unwrap()))]);
|
|
let cwd = os::getcwd();
|
|
command_line_test_with_env([~"install", ~"foo"],
|
|
&cwd,
|
|
rust_path);
|
|
|
|
assert_executable_exists(dir_to_install_to, "foo");
|
|
|
|
}
|
|
|
|
#[test]
|
|
fn sysroot_flag() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
// no-op sysroot setting; I'm not sure how else to test this
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([~"--sysroot",
|
|
test_sys.as_str().unwrap().to_owned(),
|
|
~"build",
|
|
~"foo"],
|
|
workspace);
|
|
assert_built_executable_exists(workspace, "foo");
|
|
}
|
|
|
|
#[test]
|
|
fn compile_flag_build() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([test_sys.as_str().unwrap().to_owned(),
|
|
~"build",
|
|
~"--no-link",
|
|
~"foo"],
|
|
workspace);
|
|
assert!(!built_executable_exists(workspace, "foo"));
|
|
assert!(object_file_exists(workspace, "foo"));
|
|
}
|
|
|
|
#[test]
|
|
fn compile_flag_fail() {
|
|
// --no-link shouldn't be accepted for install
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test_expect_fail([test_sys.as_str().unwrap().to_owned(),
|
|
~"install",
|
|
~"--no-link",
|
|
~"foo"],
|
|
workspace, None, BAD_FLAG_CODE);
|
|
assert!(!built_executable_exists(workspace, "foo"));
|
|
assert!(!object_file_exists(workspace, "foo"));
|
|
}
|
|
|
|
#[test]
|
|
fn notrans_flag_build() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
let flags_to_test = [~"--no-trans", ~"--parse-only",
|
|
~"--pretty", ~"-S"];
|
|
|
|
for flag in flags_to_test.iter() {
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([test_sys.as_str().unwrap().to_owned(),
|
|
~"build",
|
|
flag.clone(),
|
|
~"foo"],
|
|
workspace);
|
|
// Ideally we'd test that rustpkg actually succeeds, but
|
|
// since task failure doesn't set the exit code properly,
|
|
// we can't tell
|
|
assert!(!built_executable_exists(workspace, "foo"));
|
|
assert!(!object_file_exists(workspace, "foo"));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn notrans_flag_fail() {
|
|
// --no-trans shouldn't be accepted for install
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
let flags_to_test = [~"--no-trans", ~"--parse-only",
|
|
~"--pretty", ~"-S"];
|
|
for flag in flags_to_test.iter() {
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test_expect_fail([test_sys.as_str().unwrap().to_owned(),
|
|
~"install",
|
|
flag.clone(),
|
|
~"foo"],
|
|
workspace, None, BAD_FLAG_CODE);
|
|
assert!(!built_executable_exists(workspace, "foo"));
|
|
assert!(!object_file_exists(workspace, "foo"));
|
|
assert!(!lib_exists(workspace, &Path::new("foo"), NoVersion));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn dash_S() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([test_sys.as_str().unwrap().to_owned(),
|
|
~"build",
|
|
~"-S",
|
|
~"foo"],
|
|
workspace);
|
|
assert!(!built_executable_exists(workspace, "foo"));
|
|
assert!(!object_file_exists(workspace, "foo"));
|
|
assert!(assembly_file_exists(workspace, "foo"));
|
|
}
|
|
|
|
#[test]
|
|
fn dash_S_fail() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test_expect_fail([test_sys.as_str().unwrap().to_owned(),
|
|
~"install",
|
|
~"-S",
|
|
~"foo"],
|
|
workspace, None, BAD_FLAG_CODE);
|
|
assert!(!built_executable_exists(workspace, "foo"));
|
|
assert!(!object_file_exists(workspace, "foo"));
|
|
assert!(!assembly_file_exists(workspace, "foo"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_cfg_build() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
// If the cfg flag gets messed up, this won't compile
|
|
writeFile(&workspace.join_many(["src", "foo-0.1", "main.rs"]),
|
|
"#[cfg(quux)] fn main() {}");
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([test_sys.as_str().unwrap().to_owned(),
|
|
~"build",
|
|
~"--cfg",
|
|
~"quux",
|
|
~"foo"],
|
|
workspace);
|
|
assert_built_executable_exists(workspace, "foo");
|
|
}
|
|
|
|
#[test]
|
|
fn test_cfg_fail() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
writeFile(&workspace.join_many(["src", "foo-0.1", "main.rs"]),
|
|
"#[cfg(quux)] fn main() {}");
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
match command_line_test_partial([test_sys.as_str().unwrap().to_owned(),
|
|
~"build",
|
|
~"foo"],
|
|
workspace) {
|
|
Success(*) => fail!("test_cfg_fail failed"),
|
|
_ => ()
|
|
}
|
|
}
|
|
|
|
|
|
#[test]
|
|
fn test_emit_llvm_S_build() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([test_sys.as_str().unwrap().to_owned(),
|
|
~"build",
|
|
~"-S", ~"--emit-llvm",
|
|
~"foo"],
|
|
workspace);
|
|
assert!(!built_executable_exists(workspace, "foo"));
|
|
assert!(!object_file_exists(workspace, "foo"));
|
|
assert!(llvm_assembly_file_exists(workspace, "foo"));
|
|
assert!(!assembly_file_exists(workspace, "foo"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_emit_llvm_S_fail() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test_expect_fail([test_sys.as_str().unwrap().to_owned(),
|
|
~"install",
|
|
~"-S", ~"--emit-llvm",
|
|
~"foo"],
|
|
workspace,
|
|
None,
|
|
BAD_FLAG_CODE);
|
|
assert!(!built_executable_exists(workspace, "foo"));
|
|
assert!(!object_file_exists(workspace, "foo"));
|
|
assert!(!llvm_assembly_file_exists(workspace, "foo"));
|
|
assert!(!assembly_file_exists(workspace, "foo"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_emit_llvm_build() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([test_sys.as_str().unwrap().to_owned(),
|
|
~"build",
|
|
~"--emit-llvm",
|
|
~"foo"],
|
|
workspace);
|
|
assert!(!built_executable_exists(workspace, "foo"));
|
|
assert!(!object_file_exists(workspace, "foo"));
|
|
assert!(llvm_bitcode_file_exists(workspace, "foo"));
|
|
assert!(!assembly_file_exists(workspace, "foo"));
|
|
assert!(!llvm_assembly_file_exists(workspace, "foo"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_emit_llvm_fail() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test_expect_fail([test_sys.as_str().unwrap().to_owned(),
|
|
~"install",
|
|
~"--emit-llvm",
|
|
~"foo"],
|
|
workspace,
|
|
None,
|
|
BAD_FLAG_CODE);
|
|
assert!(!built_executable_exists(workspace, "foo"));
|
|
assert!(!object_file_exists(workspace, "foo"));
|
|
assert!(!llvm_bitcode_file_exists(workspace, "foo"));
|
|
assert!(!llvm_assembly_file_exists(workspace, "foo"));
|
|
assert!(!assembly_file_exists(workspace, "foo"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_linker_build() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
let matches = getopts([], optgroups());
|
|
let options = build_session_options(@"rustpkg",
|
|
matches.get_ref(),
|
|
@diagnostic::DefaultEmitter as
|
|
@diagnostic::Emitter);
|
|
let sess = build_session(options,
|
|
@diagnostic::DefaultEmitter as
|
|
@diagnostic::Emitter);
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([test_sys.as_str().unwrap().to_owned(),
|
|
~"install",
|
|
~"--linker",
|
|
get_cc_prog(sess),
|
|
~"foo"],
|
|
workspace);
|
|
assert_executable_exists(workspace, "foo");
|
|
}
|
|
|
|
#[test]
|
|
fn test_build_install_flags_fail() {
|
|
// The following flags can only be used with build or install:
|
|
let forbidden = [~[~"--linker", ~"ld"],
|
|
~[~"--link-args", ~"quux"],
|
|
~[~"-O"],
|
|
~[~"--opt-level", ~"2"],
|
|
~[~"--save-temps"],
|
|
~[~"--target", host_triple()],
|
|
~[~"--target-cpu", ~"generic"],
|
|
~[~"-Z", ~"--time-passes"]];
|
|
let cwd = os::getcwd();
|
|
for flag in forbidden.iter() {
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test_expect_fail([test_sys.as_str().unwrap().to_owned(),
|
|
~"list"] + *flag, &cwd, None, BAD_FLAG_CODE);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_optimized_build() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([test_sys.as_str().unwrap().to_owned(),
|
|
~"build",
|
|
~"-O",
|
|
~"foo"],
|
|
workspace);
|
|
assert!(built_executable_exists(workspace, "foo"));
|
|
}
|
|
|
|
#[test]
|
|
fn pkgid_pointing_to_subdir() {
|
|
// The actual repo is mockgithub.com/mozilla/some_repo
|
|
// rustpkg should recognize that and treat the part after some_repo/ as a subdir
|
|
let workspace = TempDir::new("parent_repo").expect("Couldn't create temp dir");
|
|
let workspace = workspace.path();
|
|
assert!(os::mkdir_recursive(&workspace.join_many(["src", "mockgithub.com",
|
|
"mozilla", "some_repo"]), U_RWX));
|
|
|
|
let foo_dir = workspace.join_many(["src", "mockgithub.com", "mozilla", "some_repo",
|
|
"extras", "foo"]);
|
|
let bar_dir = workspace.join_many(["src", "mockgithub.com", "mozilla", "some_repo",
|
|
"extras", "bar"]);
|
|
assert!(os::mkdir_recursive(&foo_dir, U_RWX));
|
|
assert!(os::mkdir_recursive(&bar_dir, U_RWX));
|
|
writeFile(&foo_dir.join("lib.rs"), "pub fn f() {}");
|
|
writeFile(&bar_dir.join("lib.rs"), "pub fn g() {}");
|
|
|
|
debug!("Creating a file in {}", workspace.display());
|
|
let testpkg_dir = workspace.join_many(["src", "testpkg-0.1"]);
|
|
assert!(os::mkdir_recursive(&testpkg_dir, U_RWX));
|
|
|
|
writeFile(&testpkg_dir.join("main.rs"),
|
|
"extern mod foo = \"mockgithub.com/mozilla/some_repo/extras/foo\";\n
|
|
extern mod bar = \"mockgithub.com/mozilla/some_repo/extras/bar\";\n
|
|
use foo::f; use bar::g; \n
|
|
fn main() { f(); g(); }");
|
|
|
|
command_line_test([~"install", ~"testpkg"], workspace);
|
|
assert_executable_exists(workspace, "testpkg");
|
|
}
|
|
|
|
#[test]
|
|
fn test_recursive_deps() {
|
|
let a_id = PkgId::new("a");
|
|
let b_id = PkgId::new("b");
|
|
let c_id = PkgId::new("c");
|
|
let b_workspace = create_local_package_with_dep(&b_id, &c_id);
|
|
let b_workspace = b_workspace.path();
|
|
writeFile(&b_workspace.join_many(["src", "c-0.1", "lib.rs"]),
|
|
"pub fn g() {}");
|
|
let a_workspace = create_local_package(&a_id);
|
|
let a_workspace = a_workspace.path();
|
|
writeFile(&a_workspace.join_many(["src", "a-0.1", "main.rs"]),
|
|
"extern mod b; use b::f; fn main() { f(); }");
|
|
writeFile(&b_workspace.join_many(["src", "b-0.1", "lib.rs"]),
|
|
"extern mod c; use c::g; pub fn f() { g(); }");
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let environment = Some(~[(~"RUST_PATH", b_workspace.as_str().unwrap().to_owned())]);
|
|
debug!("RUST_PATH={}", b_workspace.display());
|
|
command_line_test_with_env([~"install", ~"a"],
|
|
a_workspace,
|
|
environment);
|
|
assert_lib_exists(a_workspace, &Path::new("a"), NoVersion);
|
|
assert_lib_exists(b_workspace, &Path::new("b"), NoVersion);
|
|
assert_lib_exists(b_workspace, &Path::new("c"), NoVersion);
|
|
}
|
|
|
|
#[test]
|
|
fn test_install_to_rust_path() {
|
|
let p_id = PkgId::new("foo");
|
|
let second_workspace = create_local_package(&p_id);
|
|
let second_workspace = second_workspace.path();
|
|
let first_workspace = mk_empty_workspace(&Path::new("p"), &NoVersion, "dest");
|
|
let first_workspace = first_workspace.path();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let rust_path = Some(~[(~"RUST_PATH",
|
|
format!("{}:{}", first_workspace.as_str().unwrap(),
|
|
second_workspace.as_str().unwrap()))]);
|
|
debug!("RUST_PATH={}:{}", first_workspace.display(), second_workspace.display());
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test_with_env([test_sys.as_str().unwrap().to_owned(),
|
|
~"install",
|
|
~"foo"],
|
|
&os::getcwd(), rust_path);
|
|
assert!(!built_executable_exists(first_workspace, "foo"));
|
|
assert!(built_executable_exists(second_workspace, "foo"));
|
|
assert_executable_exists(first_workspace, "foo");
|
|
assert!(!executable_exists(second_workspace, "foo"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_target_specific_build_dir() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([test_sys.as_str().unwrap().to_owned(),
|
|
~"build",
|
|
~"foo"],
|
|
workspace);
|
|
assert!(os::path_is_dir(&target_build_dir(workspace)));
|
|
assert!(built_executable_exists(workspace, "foo"));
|
|
assert!(os::list_dir(&workspace.join("build")).len() == 1);
|
|
}
|
|
|
|
#[test]
|
|
fn test_target_specific_install_dir() {
|
|
let p_id = PkgId::new("foo");
|
|
let workspace = create_local_package(&p_id);
|
|
let workspace = workspace.path();
|
|
let test_sys = test_sysroot();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([test_sys.as_str().unwrap().to_owned(),
|
|
~"install",
|
|
~"foo"],
|
|
workspace);
|
|
assert!(os::path_is_dir(&workspace.join_many([~"lib", host_triple()])));
|
|
assert_lib_exists(workspace, &Path::new("foo"), NoVersion);
|
|
assert!(os::list_dir(&workspace.join("lib")).len() == 1);
|
|
assert!(os::path_is_dir(&workspace.join("bin")));
|
|
assert_executable_exists(workspace, "foo");
|
|
}
|
|
|
|
#[test]
|
|
#[ignore(reason = "See #7240")]
|
|
fn test_dependencies_terminate() {
|
|
let b_id = PkgId::new("b");
|
|
let workspace = create_local_package(&b_id);
|
|
let workspace = workspace.path();
|
|
let b_dir = workspace.join_many(["src", "b-0.1"]);
|
|
let b_subdir = b_dir.join("test");
|
|
assert!(os::mkdir_recursive(&b_subdir, U_RWX));
|
|
writeFile(&b_subdir.join("test.rs"),
|
|
"extern mod b; use b::f; #[test] fn g() { f() }");
|
|
command_line_test([~"install", ~"b"], workspace);
|
|
}
|
|
|
|
#[test]
|
|
fn install_after_build() {
|
|
let b_id = PkgId::new("b");
|
|
let workspace = create_local_package(&b_id);
|
|
let workspace = workspace.path();
|
|
command_line_test([~"build", ~"b"], workspace);
|
|
command_line_test([~"install", ~"b"], workspace);
|
|
assert_executable_exists(workspace, b_id.short_name);
|
|
assert_lib_exists(workspace, &b_id.path, NoVersion);
|
|
}
|
|
|
|
#[test]
|
|
fn reinstall() {
|
|
let b = PkgId::new("b");
|
|
let workspace = create_local_package(&b);
|
|
let workspace = workspace.path();
|
|
// 1. Install, then remove executable file, then install again,
|
|
// and make sure executable was re-installed
|
|
command_line_test([~"install", ~"b"], workspace);
|
|
assert_executable_exists(workspace, b.short_name);
|
|
assert_lib_exists(workspace, &b.path, NoVersion);
|
|
remove_executable_file(&b, workspace);
|
|
command_line_test([~"install", ~"b"], workspace);
|
|
assert_executable_exists(workspace, b.short_name);
|
|
// 2. Build, then remove build executable file, then build again,
|
|
// and make sure executable was re-built.
|
|
command_line_test([~"build", ~"b"], workspace);
|
|
remove_built_executable_file(&b, workspace);
|
|
command_line_test([~"build", ~"b"], workspace);
|
|
assert_built_executable_exists(workspace, b.short_name);
|
|
// 3. Install, then remove both executable and built executable,
|
|
// then install again, make sure both were recreated
|
|
command_line_test([~"install", ~"b"], workspace);
|
|
remove_executable_file(&b, workspace);
|
|
remove_built_executable_file(&b, workspace);
|
|
command_line_test([~"install", ~"b"], workspace);
|
|
assert_executable_exists(workspace, b.short_name);
|
|
assert_built_executable_exists(workspace, b.short_name);
|
|
}
|
|
|
|
#[test]
|
|
fn correct_package_name_with_rust_path_hack() {
|
|
/*
|
|
Set rust_path_hack flag
|
|
|
|
Try to install bar
|
|
Check that:
|
|
- no output gets produced in any workspace
|
|
- there's an error
|
|
*/
|
|
|
|
// Set RUST_PATH to something containing only the sources for foo
|
|
let foo_id = PkgId::new("foo");
|
|
let bar_id = PkgId::new("bar");
|
|
let foo_workspace = create_local_package(&foo_id);
|
|
let foo_workspace = foo_workspace.path();
|
|
let dest_workspace = mk_empty_workspace(&Path::new("bar"), &NoVersion, "dest_workspace");
|
|
let dest_workspace = dest_workspace.path();
|
|
|
|
writeFile(&dest_workspace.join_many(["src", "bar-0.1", "main.rs"]),
|
|
"extern mod blat; fn main() { let _x = (); }");
|
|
|
|
let foo_path = foo_workspace.join_many(["src", "foo-0.1"]);
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let rust_path = Some(~[(~"RUST_PATH", format!("{}:{}", dest_workspace.as_str().unwrap(),
|
|
foo_path.as_str().unwrap()))]);
|
|
// bar doesn't exist, but we want to make sure rustpkg doesn't think foo is bar
|
|
command_line_test_expect_fail([~"install", ~"--rust-path-hack", ~"bar"],
|
|
// FIXME #3408: Should be NONEXISTENT_PACKAGE_CODE
|
|
dest_workspace, rust_path, COPY_FAILED_CODE);
|
|
assert!(!executable_exists(dest_workspace, "bar"));
|
|
assert!(!lib_exists(dest_workspace, &bar_id.path.clone(), bar_id.version.clone()));
|
|
assert!(!executable_exists(dest_workspace, "foo"));
|
|
assert!(!lib_exists(dest_workspace, &foo_id.path.clone(), foo_id.version.clone()));
|
|
assert!(!executable_exists(foo_workspace, "bar"));
|
|
assert!(!lib_exists(foo_workspace, &bar_id.path.clone(), bar_id.version.clone()));
|
|
assert!(!executable_exists(foo_workspace, "foo"));
|
|
assert!(!lib_exists(foo_workspace, &foo_id.path.clone(), foo_id.version.clone()));
|
|
}
|
|
|
|
#[test]
|
|
fn test_rustpkg_test_creates_exec() {
|
|
let foo_id = PkgId::new("foo");
|
|
let foo_workspace = create_local_package(&foo_id);
|
|
let foo_workspace = foo_workspace.path();
|
|
writeFile(&foo_workspace.join_many(["src", "foo-0.1", "test.rs"]),
|
|
"#[test] fn f() { assert!('a' == 'a'); }");
|
|
command_line_test([~"test", ~"foo"], foo_workspace);
|
|
assert!(test_executable_exists(foo_workspace, "foo"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_rustpkg_test_output() {
|
|
let workspace = create_local_package_with_test(&PkgId::new("foo"));
|
|
let output = command_line_test([~"test", ~"foo"], workspace.path());
|
|
let output_str = str::from_utf8(output.output);
|
|
// The first two assertions are separate because test output may
|
|
// contain color codes, which could appear between "test f" and "ok".
|
|
assert!(output_str.contains("test f"));
|
|
assert!(output_str.contains("ok"));
|
|
assert!(output_str.contains("1 passed; 0 failed; 0 ignored; 0 measured"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_rebuild_when_needed() {
|
|
let foo_id = PkgId::new("foo");
|
|
let foo_workspace = create_local_package(&foo_id);
|
|
let foo_workspace = foo_workspace.path();
|
|
let test_crate = foo_workspace.join_many(["src", "foo-0.1", "test.rs"]);
|
|
writeFile(&test_crate, "#[test] fn f() { assert!('a' == 'a'); }");
|
|
command_line_test([~"test", ~"foo"], foo_workspace);
|
|
assert!(test_executable_exists(foo_workspace, "foo"));
|
|
let test_executable = built_test_in_workspace(&foo_id,
|
|
foo_workspace).expect("test_rebuild_when_needed failed");
|
|
frob_source_file(foo_workspace, &foo_id, "test.rs");
|
|
chmod_read_only(&test_executable);
|
|
match command_line_test_partial([~"test", ~"foo"], foo_workspace) {
|
|
Success(*) => fail!("test_rebuild_when_needed didn't rebuild"),
|
|
Fail(status) if status == 65 => (), // ok
|
|
Fail(_) => fail!("test_rebuild_when_needed failed for some other reason")
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_no_rebuilding() {
|
|
let foo_id = PkgId::new("foo");
|
|
let foo_workspace = create_local_package(&foo_id);
|
|
let foo_workspace = foo_workspace.path();
|
|
let test_crate = foo_workspace.join_many(["src", "foo-0.1", "test.rs"]);
|
|
writeFile(&test_crate, "#[test] fn f() { assert!('a' == 'a'); }");
|
|
command_line_test([~"test", ~"foo"], foo_workspace);
|
|
assert!(test_executable_exists(foo_workspace, "foo"));
|
|
let test_executable = built_test_in_workspace(&foo_id,
|
|
foo_workspace).expect("test_no_rebuilding failed");
|
|
chmod_read_only(&test_executable);
|
|
match command_line_test_partial([~"test", ~"foo"], foo_workspace) {
|
|
Success(*) => (), // ok
|
|
Fail(status) if status == 65 => fail!("test_no_rebuilding failed: it rebuilt the tests"),
|
|
Fail(_) => fail!("test_no_rebuilding failed for some other reason")
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_installed_read_only() {
|
|
// Install sources from a "remote" (actually a local github repo)
|
|
// Check that afterward, sources are read-only and installed under build/
|
|
let temp_pkg_id = git_repo_pkg();
|
|
let repo = init_git_repo(&temp_pkg_id.path);
|
|
let repo = repo.path();
|
|
debug!("repo = {}", repo.display());
|
|
let repo_subdir = repo.join_many(["mockgithub.com", "catamorphism", "test-pkg"]);
|
|
debug!("repo_subdir = {}", repo_subdir.display());
|
|
|
|
writeFile(&repo_subdir.join("main.rs"),
|
|
"fn main() { let _x = (); }");
|
|
writeFile(&repo_subdir.join("lib.rs"),
|
|
"pub fn f() { let _x = (); }");
|
|
add_git_tag(&repo_subdir, ~"0.1"); // this has the effect of committing the files
|
|
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([~"install", temp_pkg_id.path.as_str().unwrap().to_owned()], repo);
|
|
|
|
let ws = repo.join(".rust");
|
|
// Check that all files exist
|
|
debug!("Checking for files in {}", ws.display());
|
|
let exec = target_executable_in_workspace(&temp_pkg_id, &ws);
|
|
debug!("exec = {}", exec.display());
|
|
assert!(os::path_exists(&exec));
|
|
assert!(is_rwx(&exec));
|
|
let built_lib =
|
|
built_library_in_workspace(&temp_pkg_id,
|
|
&ws).expect("test_install_git: built lib should exist");
|
|
assert!(os::path_exists(&built_lib));
|
|
assert!(is_rwx(&built_lib));
|
|
|
|
// Make sure sources are (a) under "build" and (b) read-only
|
|
let src1 = target_build_dir(&ws).join_many([~"src", temp_pkg_id.to_str(), ~"main.rs"]);
|
|
let src2 = target_build_dir(&ws).join_many([~"src", temp_pkg_id.to_str(), ~"lib.rs"]);
|
|
assert!(os::path_exists(&src1));
|
|
assert!(os::path_exists(&src2));
|
|
assert!(is_read_only(&src1));
|
|
assert!(is_read_only(&src2));
|
|
}
|
|
|
|
#[test]
|
|
fn test_installed_local_changes() {
|
|
let temp_pkg_id = git_repo_pkg();
|
|
let repo = init_git_repo(&temp_pkg_id.path);
|
|
let repo = repo.path();
|
|
debug!("repo = {}", repo.display());
|
|
let repo_subdir = repo.join_many(["mockgithub.com", "catamorphism", "test-pkg"]);
|
|
debug!("repo_subdir = {}", repo_subdir.display());
|
|
assert!(os::mkdir_recursive(&repo.join_many([".rust", "src"]), U_RWX));
|
|
|
|
writeFile(&repo_subdir.join("main.rs"),
|
|
"fn main() { let _x = (); }");
|
|
writeFile(&repo_subdir.join("lib.rs"),
|
|
"pub fn f() { let _x = (); }");
|
|
add_git_tag(&repo_subdir, ~"0.1"); // this has the effect of committing the files
|
|
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([~"install", temp_pkg_id.path.as_str().unwrap().to_owned()], repo);
|
|
|
|
|
|
// We installed the dependency.
|
|
// Now start a new workspace and clone it into it
|
|
let hacking_workspace = mk_emptier_workspace("hacking_workspace");
|
|
let hacking_workspace = hacking_workspace.path();
|
|
let target_dir = hacking_workspace.join_many(["src",
|
|
"mockgithub.com",
|
|
"catamorphism",
|
|
"test-pkg-0.1"]);
|
|
debug!("---- git clone {} {}", repo_subdir.display(), target_dir.display());
|
|
|
|
let c_res = safe_git_clone(&repo_subdir, &NoVersion, &target_dir);
|
|
|
|
match c_res {
|
|
DirToUse(_) => fail!("test_installed_local_changes failed"),
|
|
CheckedOutSources => ()
|
|
};
|
|
|
|
// Make a local change to it
|
|
writeFile(&target_dir.join("lib.rs"),
|
|
"pub fn g() { let _x = (); }");
|
|
|
|
// Finally, make *another* package that uses it
|
|
let importer_pkg_id = fake_pkg();
|
|
let main_subdir = create_local_package_in(&importer_pkg_id, hacking_workspace);
|
|
writeFile(&main_subdir.join("main.rs"),
|
|
"extern mod test = \"mockgithub.com/catamorphism/test-pkg\"; \
|
|
use test::g;
|
|
fn main() { g(); }");
|
|
// And make sure we can build it
|
|
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
command_line_test([~"build", importer_pkg_id.path.as_str().unwrap().to_owned()],
|
|
hacking_workspace);
|
|
}
|
|
|
|
#[test]
|
|
fn test_7402() {
|
|
let dir = create_local_package(&PkgId::new("foo"));
|
|
let dest_workspace = TempDir::new("more_rust").expect("test_7402");
|
|
let dest_workspace = dest_workspace.path();
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let rust_path = Some(~[(~"RUST_PATH",
|
|
format!("{}:{}", dest_workspace.as_str().unwrap(),
|
|
dir.path().as_str().unwrap()))]);
|
|
let cwd = os::getcwd();
|
|
command_line_test_with_env([~"install", ~"foo"], &cwd, rust_path);
|
|
assert_executable_exists(dest_workspace, "foo");
|
|
}
|
|
|
|
#[test]
|
|
fn test_compile_error() {
|
|
let foo_id = PkgId::new("foo");
|
|
let foo_workspace = create_local_package(&foo_id);
|
|
let foo_workspace = foo_workspace.path();
|
|
let main_crate = foo_workspace.join_many(["src", "foo-0.1", "main.rs"]);
|
|
// Write something bogus
|
|
writeFile(&main_crate, "pub fn main() { if 42 != ~\"the answer\" { fail!(); } }");
|
|
let result = command_line_test_partial([~"build", ~"foo"], foo_workspace);
|
|
match result {
|
|
Success(*) => fail!("Failed by succeeding!"), // should be a compile error
|
|
Fail(status) => {
|
|
debug!("Failed with status {:?}... that's good, right?", status);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn find_sources_in_cwd() {
|
|
let temp_dir = TempDir::new("sources").expect("find_sources_in_cwd failed");
|
|
let temp_dir = temp_dir.path();
|
|
let source_dir = temp_dir.join("foo");
|
|
os::mkdir_recursive(&source_dir, U_RWX);
|
|
writeFile(&source_dir.join("main.rs"),
|
|
"fn main() { let _x = (); }");
|
|
command_line_test([~"install", ~"foo"], &source_dir);
|
|
assert_executable_exists(&source_dir.join(".rust"), "foo");
|
|
}
|
|
|
|
#[test]
|
|
fn test_c_dependency_ok() {
|
|
// Pkg has a custom build script that adds a single C file as a dependency, and
|
|
// registers a hook to build it if it's not fresh
|
|
// After running `build`, test that the C library built
|
|
|
|
let dir = create_local_package(&PkgId::new("cdep"));
|
|
let dir = dir.path();
|
|
writeFile(&dir.join_many(["src", "cdep-0.1", "main.rs"]),
|
|
"#[link_args = \"-lfoo\"]\nextern { fn f(); } \
|
|
\n#[fixed_stack_segment]\nfn main() { unsafe { f(); } }");
|
|
writeFile(&dir.join_many(["src", "cdep-0.1", "foo.c"]), "void f() {}");
|
|
|
|
debug!("dir = {}", dir.display());
|
|
let source = Path::new(file!()).dir_path().join_many(
|
|
[~"testsuite", ~"pass", ~"src", ~"c-dependencies", ~"pkg.rs"]);
|
|
if !os::copy_file(&source,
|
|
&dir.join_many([~"src", ~"cdep-0.1", ~"pkg.rs"])) {
|
|
fail!("Couldn't copy file");
|
|
}
|
|
command_line_test([~"build", ~"cdep"], dir);
|
|
assert_executable_exists(dir, "cdep");
|
|
let out_dir = target_build_dir(dir).join("cdep");
|
|
let c_library_path = out_dir.join(platform_library_name("foo"));
|
|
debug!("c library path: {}", c_library_path.display());
|
|
assert!(os::path_exists(&c_library_path));
|
|
}
|
|
|
|
#[test]
|
|
fn test_c_dependency_no_rebuilding() {
|
|
let dir = create_local_package(&PkgId::new("cdep"));
|
|
let dir = dir.path();
|
|
writeFile(&dir.join_many(["src", "cdep-0.1", "main.rs"]),
|
|
"#[link_args = \"-lfoo\"]\nextern { fn f(); } \
|
|
\n#[fixed_stack_segment]\nfn main() { unsafe { f(); } }");
|
|
writeFile(&dir.join_many(["src", "cdep-0.1", "foo.c"]), "void f() {}");
|
|
|
|
debug!("dir = {}", dir.display());
|
|
let source = Path::new(file!()).dir_path().join_many(
|
|
[~"testsuite", ~"pass", ~"src", ~"c-dependencies", ~"pkg.rs"]);
|
|
if !os::copy_file(&source,
|
|
&dir.join_many([~"src", ~"cdep-0.1", ~"pkg.rs"])) {
|
|
fail!("Couldn't copy file");
|
|
}
|
|
command_line_test([~"build", ~"cdep"], dir);
|
|
assert_executable_exists(dir, "cdep");
|
|
let out_dir = target_build_dir(dir).join("cdep");
|
|
let c_library_path = out_dir.join(platform_library_name("foo"));
|
|
debug!("c library path: {}", c_library_path.display());
|
|
assert!(os::path_exists(&c_library_path));
|
|
|
|
// Now, make it read-only so rebuilding will fail
|
|
assert!(chmod_read_only(&c_library_path));
|
|
|
|
match command_line_test_partial([~"build", ~"cdep"], dir) {
|
|
Success(*) => (), // ok
|
|
Fail(status) if status == 65 => fail!("test_c_dependency_no_rebuilding failed: \
|
|
it tried to rebuild foo.c"),
|
|
Fail(_) => fail!("test_c_dependency_no_rebuilding failed for some other reason")
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_c_dependency_yes_rebuilding() {
|
|
let dir = create_local_package(&PkgId::new("cdep"));
|
|
let dir = dir.path();
|
|
writeFile(&dir.join_many(["src", "cdep-0.1", "main.rs"]),
|
|
"#[link_args = \"-lfoo\"]\nextern { fn f(); } \
|
|
\n#[fixed_stack_segment]\nfn main() { unsafe { f(); } }");
|
|
let c_file_name = dir.join_many(["src", "cdep-0.1", "foo.c"]);
|
|
writeFile(&c_file_name, "void f() {}");
|
|
|
|
let source = Path::new(file!()).dir_path().join_many(
|
|
[~"testsuite", ~"pass", ~"src", ~"c-dependencies", ~"pkg.rs"]);
|
|
let target = dir.join_many([~"src", ~"cdep-0.1", ~"pkg.rs"]);
|
|
debug!("Copying {} -> {}", source.display(), target.display());
|
|
if !os::copy_file(&source, &target) {
|
|
fail!("Couldn't copy file");
|
|
}
|
|
command_line_test([~"build", ~"cdep"], dir);
|
|
assert_executable_exists(dir, "cdep");
|
|
let out_dir = target_build_dir(dir).join("cdep");
|
|
let c_library_path = out_dir.join(platform_library_name("foo"));
|
|
debug!("c library path: {}", c_library_path.display());
|
|
assert!(os::path_exists(&c_library_path));
|
|
|
|
// Now, make the Rust library read-only so rebuilding will fail
|
|
match built_library_in_workspace(&PkgId::new("cdep"), dir) {
|
|
Some(ref pth) => assert!(chmod_read_only(pth)),
|
|
None => assert_built_library_exists(dir, "cdep")
|
|
}
|
|
|
|
match command_line_test_partial([~"build", ~"cdep"], dir) {
|
|
Success(*) => fail!("test_c_dependency_yes_rebuilding failed: \
|
|
it didn't rebuild and should have"),
|
|
Fail(status) if status == 65 => (),
|
|
Fail(_) => fail!("test_c_dependency_yes_rebuilding failed for some other reason")
|
|
}
|
|
}
|
|
|
|
/// Returns true if p exists and is executable
|
|
fn is_executable(p: &Path) -> bool {
|
|
use std::libc::consts::os::posix88::{S_IXUSR};
|
|
|
|
match p.get_mode() {
|
|
None => false,
|
|
Some(mode) => mode & S_IXUSR as uint == S_IXUSR as uint
|
|
}
|
|
}
|