compiletest: remove --host and cleanup

3 files changed, 144 insertions, 144 deletions

diff --git a/src/compiletest/common.rs b/src/compiletest/common.rs
index 87a7dae5a7f..38289f62741 100644
--- a/src/compiletest/common.rs
+++ b/src/compiletest/common.rs
@@ -64,10 +64,7 @@ pub struct config {
     // Run tests using the new runtime
     newrt: bool,
 
-    // Host System to be built
-    host: ~str,
-
-    // Target System to be executed
+    // Target system to be tested
     target: ~str,
 
     // Extra parameter to run adb on arm-linux-androideabi
@@ -76,8 +73,8 @@ pub struct config {
     // Extra parameter to run test sute on arm-linux-androideabi
     adb_test_dir: ~str,
 
-    // check if can be run or not
-    flag_runnable: bool,
+    // status whether android device available or not
+    adb_device_status: bool,
 
     // Explain what's going on
     verbose: bool
diff --git a/src/compiletest/compiletest.rc b/src/compiletest/compiletest.rc
index fab73d78021..3fb6937819e 100644
--- a/src/compiletest/compiletest.rc
+++ b/src/compiletest/compiletest.rc
@@ -61,7 +61,6 @@ pub fn parse_config(args: ~[~str]) -> config {
           getopts::optopt(~"logfile"),
           getopts::optflag(~"jit"),
           getopts::optflag(~"newrt"),
-          getopts::optopt(~"host"),
           getopts::optopt(~"target"),
           getopts::optopt(~"adb-path"),
           getopts::optopt(~"adb-test-dir")
@@ -98,25 +97,18 @@ pub fn parse_config(args: ~[~str]) -> config {
         rustcflags: getopts::opt_maybe_str(matches, ~"rustcflags"),
         jit: getopts::opt_present(matches, ~"jit"),
         newrt: getopts::opt_present(matches, ~"newrt"),
-        host: opt_str(getopts::opt_maybe_str(matches, ~"host")),
         target: opt_str(getopts::opt_maybe_str(matches, ~"target")),
         adb_path: opt_str(getopts::opt_maybe_str(matches, ~"adb-path")),
         adb_test_dir: opt_str(getopts::opt_maybe_str(matches, ~"adb-test-dir")),
-        flag_runnable:
-            if (getopts::opt_maybe_str(matches, ~"host") ==
-                getopts::opt_maybe_str(matches, ~"target")) { true }
-            else {
-                match getopts::opt_maybe_str(matches, ~"target") {
-                    Some(~"arm-linux-androideabi") => {
-                        if (opt_str(getopts::opt_maybe_str(matches, ~"adb-test-dir")) !=
-                            ~"(none)" &&
-                            opt_str(getopts::opt_maybe_str(matches, ~"adb-test-dir")) !=
-                            ~"") { true }
-                        else { false }
-                    }
-                    _ => { true }
-                }
-            },
+        adb_device_status:
+            if (opt_str(getopts::opt_maybe_str(matches, ~"target")) ==
+                ~"arm-linux-androideabi") {
+                if (opt_str(getopts::opt_maybe_str(matches, ~"adb-test-dir")) !=
+                    ~"(none)" &&
+                    opt_str(getopts::opt_maybe_str(matches, ~"adb-test-dir")) !=
+                    ~"") { true }
+                else { false }
+            } else { false },
         verbose: getopts::opt_present(matches, ~"verbose")
     }
 }
@@ -137,11 +129,10 @@ pub fn log_config(config: config) {
     logv(c, fmt!("rustcflags: %s", opt_str(config.rustcflags)));
     logv(c, fmt!("jit: %b", config.jit));
     logv(c, fmt!("newrt: %b", config.newrt));
-    logv(c, fmt!("host: %s", config.host));
     logv(c, fmt!("target: %s", config.target));
     logv(c, fmt!("adb_path: %s", config.adb_path));
     logv(c, fmt!("adb_test_dir: %s", config.adb_test_dir));
-    logv(c, fmt!("flag_runnable: %b", config.flag_runnable));
+    logv(c, fmt!("adb_device_status: %b", config.adb_device_status));
     logv(c, fmt!("verbose: %b", config.verbose));
     logv(c, fmt!("\n"));
 }
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
index d1319c395ad..07b439174be 100644
--- a/src/compiletest/runtest.rs
+++ b/src/compiletest/runtest.rs
@@ -77,18 +77,19 @@ fn run_rfail_test(config: config, props: TestProps, testfile: &Path) {
         fatal_ProcRes(~"run-fail test isn't valgrind-clean!", ProcRes);
     }
 
-    if (config.host == config.target) {
-        check_correct_failure_status(ProcRes);
-        check_error_patterns(props, testfile, ProcRes);
-    } else {
-        match (config.target, config.flag_runnable) {
+    match config.target {
 
-            (~"arm-linux-androideabi", false) => { }
-            _ => {
+        ~"arm-linux-androideabi" => {
+            if (config.adb_device_status) {
                 check_correct_failure_status(ProcRes);
                 check_error_patterns(props, testfile, ProcRes);
             }
         }
+
+        _=> {
+            check_correct_failure_status(ProcRes);
+            check_error_patterns(props, testfile, ProcRes);
+        }
     }
 }
 
@@ -494,99 +495,21 @@ fn exec_compiled_test(config: config, props: TestProps,
         props.exec_env
     };
 
-    if (config.host == config.target) {
-        compose_and_run(config, testfile,
-                        make_run_args(config, props, testfile),
-                        env,
-                        config.run_lib_path, None)
-    } else {
-        let args = make_run_args(config, props, testfile);
-        let cmdline = make_cmdline(~"", args.prog, args.args);
-
-        match (config.target, config.flag_runnable) {
-
-            (~"arm-linux-androideabi", true) => {
-
-                // get bare program string
-                let mut tvec = ~[];
-                let tstr = args.prog;
-                for str::each_split_char(tstr, '/') |ts| { tvec.push(ts.to_owned()) }
-                let prog_short = tvec.pop();
-
-                // copy to target
-                let copy_result = procsrv::run(~"", config.adb_path,
-                    ~[~"push", args.prog, config.adb_test_dir],
-                    ~[(~"",~"")], Some(~""));
-
-                if config.verbose {
-                    io::stdout().write_str(fmt!("push (%s) %s %s %s",
-                        config.target, args.prog,
-                        copy_result.out, copy_result.err));
-                }
-
-                // execute program
-                logv(config, fmt!("executing (%s) %s", config.target, cmdline));
-
-                // NOTE: adb shell dose not forward stdout and stderr of internal result
-                //       to stdout and stderr seperately but to stdout only
-                let mut newargs_out = ~[];
-                let mut newargs_err = ~[];
-                let subargs = args.args;
-                newargs_out.push(~"shell");
-                newargs_err.push(~"shell");
-
-                let mut newcmd_out = ~"";
-                let mut newcmd_err = ~"";
-
-                newcmd_out.push_str(fmt!("LD_LIBRARY_PATH=%s %s/%s",
-                    config.adb_test_dir, config.adb_test_dir, prog_short));
-
-                newcmd_err.push_str(fmt!("LD_LIBRARY_PATH=%s %s/%s",
-                    config.adb_test_dir, config.adb_test_dir, prog_short));
-
-                for vec::each(subargs) |tv| {
-                    newcmd_out.push_str(" ");
-                    newcmd_err.push_str(" ");
-                    newcmd_out.push_str(tv.to_owned());
-                    newcmd_err.push_str(tv.to_owned());
-                }
-
-                newcmd_out.push_str(" 2>/dev/null");
-                newcmd_err.push_str(" 1>/dev/null");
-
-                newargs_out.push(newcmd_out);
-                newargs_err.push(newcmd_err);
-
-                let exe_result_out = procsrv::run(~"", config.adb_path,
-                    newargs_out, ~[(~"",~"")], Some(~""));
-                let exe_result_err = procsrv::run(~"", config.adb_path,
-                    newargs_err, ~[(~"",~"")], Some(~""));
+    match config.target {
 
-                dump_output(config, testfile, exe_result_out.out, exe_result_err.out);
-
-                match exe_result_err.out {
-                    ~"" => ProcRes {status: exe_result_out.status, stdout: exe_result_out.out,
-                        stderr: exe_result_err.out, cmdline: cmdline },
-                    _   => ProcRes {status: 101, stdout: exe_result_out.out,
-                        stderr: exe_result_err.out, cmdline: cmdline }
-                }
-            }
-
-            (~"arm-linux-androideabi", false) => {
-                match config.mode {
-                    mode_run_fail => ProcRes {status: 101, stdout: ~"",
-                                             stderr: ~"", cmdline: cmdline},
-                    _             => ProcRes {status: 0, stdout: ~"",
-                                             stderr: ~"", cmdline: cmdline}
-                }
+        ~"arm-linux-androideabi" => {
+            if (config.adb_device_status) {
+                _arm_exec_compiled_test(config, props, testfile)
+            } else {
+                _dummy_exec_compiled_test(config, props, testfile)
             }
+        }
 
-            _=> {
-                compose_and_run(config, testfile,
-                                make_run_args(config, props, testfile),
-                                env,
-                                config.run_lib_path, None)
-            }
+        _=> {
+            compose_and_run(config, testfile,
+                            make_run_args(config, props, testfile),
+                            env,
+                            config.run_lib_path, None)
         }
     }
 }
@@ -618,32 +541,16 @@ fn compose_and_run_compiler(
                      abs_ab.to_str()),
                 auxres);
         }
-        if (config.host != config.target)
-        {
-            match (config.target, config.flag_runnable) {
-
-                (~"arm-linux-androideabi", true) => {
-
-                    let tstr = aux_output_dir_name(config, testfile).to_str();
-
-                    for os::list_dir_path(&Path(tstr)).each |file| {
 
-                        if (file.filetype() == Some(~".so")) {
+        match config.target {
 
-                            let copy_result = procsrv::run(~"", config.adb_path,
-                                ~[~"push", file.to_str(), config.adb_test_dir],
-                                ~[(~"",~"")], Some(~""));
-
-                            if config.verbose {
-                                io::stdout().write_str(fmt!("push (%s) %s %s %s",
-                                    config.target, file.to_str(),
-                                    copy_result.out, copy_result.err));
-                            }
-                        }
-                    }
+            ~"arm-linux-androideabi" => {
+                if (config.adb_device_status) {
+                    _arm_push_aux_shared_library(config, testfile);
                 }
-                _=> ()
             }
+
+            _=> { }
         }
     }
 
@@ -829,3 +736,108 @@ stderr:\n\
     io::stdout().write_str(msg);
     fail!();
 }
+
+fn _arm_exec_compiled_test(config: config, props: TestProps,
+                      testfile: &Path) -> ProcRes {
+
+    let args = make_run_args(config, props, testfile);
+    let cmdline = make_cmdline(~"", args.prog, args.args);
+
+    // get bare program string
+    let mut tvec = ~[];
+    let tstr = args.prog;
+    for str::each_split_char(tstr, '/') |ts| { tvec.push(ts.to_owned()) }
+    let prog_short = tvec.pop();
+
+    // copy to target
+    let copy_result = procsrv::run(~"", config.adb_path,
+        ~[~"push", args.prog, config.adb_test_dir],
+        ~[(~"",~"")], Some(~""));
+
+    if config.verbose {
+        io::stdout().write_str(fmt!("push (%s) %s %s %s",
+            config.target, args.prog,
+            copy_result.out, copy_result.err));
+    }
+
+    // execute program
+    logv(config, fmt!("executing (%s) %s", config.target, cmdline));
+
+    // adb shell dose not forward stdout and stderr of internal result
+    // to stdout and stderr seperately but to stdout only
+    let mut newargs_out = ~[];
+    let mut newargs_err = ~[];
+    let subargs = args.args;
+    newargs_out.push(~"shell");
+    newargs_err.push(~"shell");
+
+    let mut newcmd_out = ~"";
+    let mut newcmd_err = ~"";
+
+    newcmd_out.push_str(fmt!("LD_LIBRARY_PATH=%s %s/%s",
+        config.adb_test_dir, config.adb_test_dir, prog_short));
+
+    newcmd_err.push_str(fmt!("LD_LIBRARY_PATH=%s %s/%s",
+        config.adb_test_dir, config.adb_test_dir, prog_short));
+
+    for vec::each(subargs) |tv| {
+        newcmd_out.push_str(" ");
+        newcmd_err.push_str(" ");
+        newcmd_out.push_str(tv.to_owned());
+        newcmd_err.push_str(tv.to_owned());
+    }
+
+    newcmd_out.push_str(" 2>/dev/null");
+    newcmd_err.push_str(" 1>/dev/null");
+
+    newargs_out.push(newcmd_out);
+    newargs_err.push(newcmd_err);
+
+    let exe_result_out = procsrv::run(~"", config.adb_path,
+        newargs_out, ~[(~"",~"")], Some(~""));
+    let exe_result_err = procsrv::run(~"", config.adb_path,
+        newargs_err, ~[(~"",~"")], Some(~""));
+
+    dump_output(config, testfile, exe_result_out.out, exe_result_err.out);
+
+    match exe_result_err.out {
+        ~"" => ProcRes {status: exe_result_out.status, stdout: exe_result_out.out,
+            stderr: exe_result_err.out, cmdline: cmdline },
+        _   => ProcRes {status: 101, stdout: exe_result_out.out,
+            stderr: exe_result_err.out, cmdline: cmdline }
+    }
+}
+
+fn _dummy_exec_compiled_test(config: config, props: TestProps,
+                      testfile: &Path) -> ProcRes {
+
+    let args = make_run_args(config, props, testfile);
+    let cmdline = make_cmdline(~"", args.prog, args.args);
+
+    match config.mode {
+        mode_run_fail => ProcRes {status: 101, stdout: ~"",
+                                 stderr: ~"", cmdline: cmdline},
+        _             => ProcRes {status: 0, stdout: ~"",
+                                 stderr: ~"", cmdline: cmdline}
+    }
+}
+
+fn _arm_push_aux_shared_library(config: config, testfile: &Path) {
+    let tstr = aux_output_dir_name(config, testfile).to_str();
+
+    for os::list_dir_path(&Path(tstr)).each |file| {
+
+        if (file.filetype() == Some(~".so")) {
+
+            let copy_result = procsrv::run(~"", config.adb_path,
+                ~[~"push", file.to_str(), config.adb_test_dir],
+                ~[(~"",~"")], Some(~""));
+
+            if config.verbose {
+                io::stdout().write_str(fmt!("push (%s) %s %s %s",
+                    config.target, file.to_str(),
+                    copy_result.out, copy_result.err));
+            }
+        }
+    }
+}