From 4007006574561280139659a42000321020d589ff Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Tue, 30 Aug 2011 15:40:25 -0700 Subject: [PATCH] Convert compiletest to istrs. Issue #855 --- src/test/compiletest/compiletest.rs | 101 +++++++------ src/test/compiletest/header.rs | 70 ++++----- src/test/compiletest/procsrv.rs | 50 ++++--- src/test/compiletest/runtest.rs | 224 +++++++++++++++------------- src/test/compiletest/util.rs | 18 ++- 5 files changed, 249 insertions(+), 214 deletions(-) diff --git a/src/test/compiletest/compiletest.rs b/src/test/compiletest/compiletest.rs index 05451f508e9..bc029b407b8 100644 --- a/src/test/compiletest/compiletest.rs +++ b/src/test/compiletest/compiletest.rs @@ -23,14 +23,13 @@ import common::mode; import util::logv; fn main(args: [str]) { - + let args = istr::from_estrs(args); let config = parse_config(args); log_config(config); run_tests(config); } -fn parse_config(args: &[str]) -> config { - let args = istr::from_estrs(args); +fn parse_config(args: &[istr]) -> config { let opts = [getopts::reqopt(~"compile-lib-path"), getopts::reqopt(~"run-lib-path"), @@ -60,7 +59,7 @@ fn parse_config(args: &[str]) -> config { src_base: getopts::opt_str(match, ~"src-base"), build_base: getopts::opt_str(match, ~"build-base"), stage_id: getopts::opt_str(match, ~"stage-id"), - mode: str_mode(istr::to_estr(getopts::opt_str(match, ~"mode"))), + mode: str_mode(getopts::opt_str(match, ~"mode")), run_ignored: getopts::opt_present(match, ~"ignored"), filter: if vec::len(match.free) > 0u { @@ -73,27 +72,40 @@ fn parse_config(args: &[str]) -> config { fn log_config(config: &config) { let c = config; - logv(c, #fmt["configuration:"]); - logv(c, #fmt["compile_lib_path: %s", - istr::to_estr(config.compile_lib_path)]); - logv(c, #fmt["run_lib_path: %s", istr::to_estr(config.run_lib_path)]); - logv(c, #fmt["rustc_path: %s", istr::to_estr(config.rustc_path)]); - logv(c, #fmt["src_base: %s", istr::to_estr(config.src_base)]); - logv(c, #fmt["build_base: %s", istr::to_estr(config.build_base)]); - logv(c, #fmt["stage_id: %s", istr::to_estr(config.stage_id)]); - logv(c, #fmt["mode: %s", mode_str(config.mode)]); - logv(c, #fmt["run_ignored: %b", config.run_ignored]); - logv(c, #fmt["filter: %s", opt_str(config.filter)]); - logv(c, #fmt["runtool: %s", opt_str(config.runtool)]); - logv(c, #fmt["rustcflags: %s", opt_str(config.rustcflags)]); - logv(c, #fmt["verbose: %b", config.verbose]); - logv(c, #fmt["\n"]); + logv(c, istr::from_estr( + #fmt["configuration:"])); + logv(c, istr::from_estr( + #fmt["compile_lib_path: %s", + istr::to_estr(config.compile_lib_path)])); + logv(c, istr::from_estr( + #fmt["run_lib_path: %s", istr::to_estr(config.run_lib_path)])); + logv(c, istr::from_estr( + #fmt["rustc_path: %s", istr::to_estr(config.rustc_path)])); + logv(c, istr::from_estr( + #fmt["src_base: %s", istr::to_estr(config.src_base)])); + logv(c, istr::from_estr( + #fmt["build_base: %s", istr::to_estr(config.build_base)])); + logv(c, istr::from_estr( + #fmt["stage_id: %s", istr::to_estr(config.stage_id)])); + logv(c, istr::from_estr( + #fmt["mode: %s", istr::to_estr(mode_str(config.mode))])); + logv(c, istr::from_estr( + #fmt["run_ignored: %b", config.run_ignored])); + logv(c, istr::from_estr( + #fmt["filter: %s", istr::to_estr(opt_str(config.filter))])); + logv(c, istr::from_estr( + #fmt["runtool: %s", istr::to_estr(opt_str(config.runtool))])); + logv(c, istr::from_estr( + #fmt["rustcflags: %s", istr::to_estr(opt_str(config.rustcflags))])); + logv(c, istr::from_estr( + #fmt["verbose: %b", config.verbose])); + logv(c, istr::from_estr(#fmt["\n"])); } -fn opt_str(maybestr: option::t) -> str { +fn opt_str(maybestr: option::t) -> istr { alt maybestr { - option::some(s) { istr::to_estr(s) } - option::none. { "(none)" } + option::some(s) { s } + option::none. { ~"(none)" } } } @@ -101,8 +113,8 @@ fn str_opt(maybestr: &istr) -> option::t { if maybestr != ~"(none)" { option::some(maybestr) } else { option::none } } -fn str_mode(s: str) -> mode { - alt s { +fn str_mode(s: &istr) -> mode { + alt istr::to_estr(s) { "compile-fail" { mode_compile_fail } "run-fail" { mode_run_fail } "run-pass" { mode_run_pass } @@ -111,12 +123,12 @@ fn str_mode(s: str) -> mode { } } -fn mode_str(mode: mode) -> str { +fn mode_str(mode: mode) -> istr { alt mode { - mode_compile_fail. { "compile-fail" } - mode_run_fail. { "run-fail" } - mode_run_pass. { "run-pass" } - mode_pretty. { "pretty" } + mode_compile_fail. { ~"compile-fail" } + mode_run_fail. { ~"run-fail" } + mode_run_pass. { ~"run-pass" } + mode_pretty. { ~"pretty" } } } @@ -146,8 +158,7 @@ fn make_tests(cx: &cx) -> tests_and_conv_fn { let configport = port::<[u8]>(); let tests = []; for file: istr in fs::list_dir(cx.config.src_base) { - let file = istr::to_estr(file); - log #fmt["inspecting file %s", file]; + log #fmt["inspecting file %s", istr::to_estr(file)]; if is_test(cx.config, file) { tests += [make_test(cx, file, configport)]; } @@ -155,14 +166,14 @@ fn make_tests(cx: &cx) -> tests_and_conv_fn { ret {tests: tests, to_task: bind closure_to_task(cx, configport, _)}; } -fn is_test(config: &config, testfile: &str) -> bool { +fn is_test(config: &config, testfile: &istr) -> bool { // Pretty-printer does not work with .rc files yet let valid_extensions = alt config.mode { mode_pretty. { [~".rs"] } _ { [~".rc", ~".rs"] } }; let invalid_prefixes = [~".", ~"#", ~"~"]; - let name = fs::basename(istr::from_estr(testfile)); + let name = fs::basename(testfile); let valid = false; @@ -177,15 +188,17 @@ fn is_test(config: &config, testfile: &str) -> bool { ret valid; } -fn make_test(cx: &cx, testfile: &str, configport: &port<[u8]>) -> +fn make_test(cx: &cx, testfile: &istr, configport: &port<[u8]>) -> test::test_desc { {name: make_test_name(cx.config, testfile), fn: make_test_closure(testfile, chan(configport)), ignore: header::is_test_ignored(cx.config, testfile)} } -fn make_test_name(config: &config, testfile: &str) -> str { - #fmt["[%s] %s", mode_str(config.mode), testfile] +fn make_test_name(config: &config, testfile: &istr) -> str { + #fmt["[%s] %s", + istr::to_estr(mode_str(config.mode)), + istr::to_estr(testfile)] } /* @@ -207,13 +220,13 @@ up. Then we'll spawn that data into another task and return the task. Really convoluted. Need to think up of a better definition for tests. */ -fn make_test_closure(testfile: &str, configchan: chan<[u8]>) -> +fn make_test_closure(testfile: &istr, configchan: chan<[u8]>) -> test::test_fn { bind send_config(testfile, configchan) } -fn send_config(testfile: str, configchan: chan<[u8]>) { - send(configchan, str::bytes(testfile)); +fn send_config(testfile: istr, configchan: chan<[u8]>) { + send(configchan, istr::bytes(testfile)); } /* @@ -237,11 +250,11 @@ fn closure_to_task(cx: cx, configport: port<[u8]>, testfn: &fn()) -> let src_base = cx.config.src_base; let build_base = cx.config.build_base; let stage_id = cx.config.stage_id; - let mode = istr::from_estr(mode_str(cx.config.mode)); + let mode = mode_str(cx.config.mode); let run_ignored = cx.config.run_ignored; - let filter = istr::from_estr(opt_str(cx.config.filter)); - let runtool = istr::from_estr(opt_str(cx.config.runtool)); - let rustcflags = istr::from_estr(opt_str(cx.config.rustcflags)); + let filter = opt_str(cx.config.filter); + let runtool = opt_str(cx.config.runtool); + let rustcflags = opt_str(cx.config.rustcflags); let verbose = cx.config.verbose; let chan = cx.procsrv.chan; @@ -277,7 +290,7 @@ fn run_test_task(compile_lib_path: -istr, run_lib_path: -istr, src_base: src_base, build_base: build_base, stage_id: stage_id, - mode: str_mode(istr::to_estr(mode)), + mode: str_mode(mode), run_ignored: run_ignored, filter: str_opt(opt_filter), runtool: str_opt(opt_runtool), diff --git a/src/test/compiletest/header.rs b/src/test/compiletest/header.rs index 0d1121e4b6b..d953a903c39 100644 --- a/src/test/compiletest/header.rs +++ b/src/test/compiletest/header.rs @@ -12,24 +12,24 @@ export is_test_ignored; type test_props = { // Lines that should be expected, in order, on standard out - error_patterns: [str], + error_patterns: [istr], // Extra flags to pass to the compiler - compile_flags: option::t, + compile_flags: option::t, // If present, the name of a file that this test should match when // pretty-printed - pp_exact: option::t, + pp_exact: option::t, // FIXME: no-valgrind is a temporary directive until all of run-fail // is valgrind-clean no_valgrind: bool }; // Load any test directives embedded in the file -fn load_props(testfile: &str) -> test_props { +fn load_props(testfile: &istr) -> test_props { let error_patterns = []; let compile_flags = option::none; let pp_exact = option::none; let no_valgrind = false; - for each ln: str in iter_header(testfile) { + for each ln: istr in iter_header(testfile) { alt parse_error_pattern(ln) { option::some(ep) { error_patterns += [ep]; } option::none. { } @@ -44,7 +44,7 @@ fn load_props(testfile: &str) -> test_props { } if no_valgrind == false { - no_valgrind = parse_name_directive(ln, "no-valgrind"); + no_valgrind = parse_name_directive(ln, ~"no-valgrind"); } } ret { @@ -55,50 +55,50 @@ fn load_props(testfile: &str) -> test_props { }; } -fn is_test_ignored(config: &config, testfile: &str) -> bool { +fn is_test_ignored(config: &config, testfile: &istr) -> bool { let found = false; - for each ln: str in iter_header(testfile) { + for each ln: istr in iter_header(testfile) { // FIXME: Can't return or break from iterator found = found - || parse_name_directive(ln, "xfail-" - + istr::to_estr(config.stage_id)); + || parse_name_directive(ln, ~"xfail-" + + config.stage_id); if (config.mode == common::mode_pretty) { found = found - || parse_name_directive(ln, "xfail-pretty"); + || parse_name_directive(ln, ~"xfail-pretty"); } } ret found; } -iter iter_header(testfile: &str) -> str { - let rdr = io::file_reader(istr::from_estr(testfile)); +iter iter_header(testfile: &istr) -> istr { + let rdr = io::file_reader(testfile); while !rdr.eof() { - let ln = istr::to_estr(rdr.read_line()); + let ln = rdr.read_line(); // Assume that any directives will be found before the first // module or function. This doesn't seem to be an optimization // with a warm page cache. Maybe with a cold one. - if str::starts_with(ln, "fn") || str::starts_with(ln, "mod") { + if istr::starts_with(ln, ~"fn") + || istr::starts_with(ln, ~"mod") { break; } else { put ln; } } } -fn parse_error_pattern(line: &str) -> option::t { - parse_name_value_directive(line, "error-pattern") +fn parse_error_pattern(line: &istr) -> option::t { + parse_name_value_directive(line, ~"error-pattern") } -fn parse_compile_flags(line: &str) -> option::t { - parse_name_value_directive(line, "compile-flags") +fn parse_compile_flags(line: &istr) -> option::t { + parse_name_value_directive(line, ~"compile-flags") } -fn parse_pp_exact(line: &str, testfile: &str) -> option::t { - alt parse_name_value_directive(line, "pp-exact") { +fn parse_pp_exact(line: &istr, testfile: &istr) -> option::t { + alt parse_name_value_directive(line, ~"pp-exact") { option::some(s) { option::some(s) } option::none. { - if parse_name_directive(line, "pp-exact") { - option::some(istr::to_estr( - fs::basename(istr::from_estr(testfile)))) + if parse_name_directive(line, ~"pp-exact") { + option::some(fs::basename(testfile)) } else { option::none } @@ -106,19 +106,21 @@ fn parse_pp_exact(line: &str, testfile: &str) -> option::t { } } -fn parse_name_directive(line: &str, directive: &str) -> bool { - str::find(line, directive) >= 0 +fn parse_name_directive(line: &istr, directive: &istr) -> bool { + istr::find(line, directive) >= 0 } -fn parse_name_value_directive(line: &str, - directive: &str) -> option::t { - let keycolon = directive + ":"; - if str::find(line, keycolon) >= 0 { - let colon = str::find(line, keycolon) as uint; +fn parse_name_value_directive(line: &istr, + directive: &istr) -> option::t { + let keycolon = directive + ~":"; + if istr::find(line, keycolon) >= 0 { + let colon = istr::find(line, keycolon) as uint; let value = - str::slice(line, colon + str::byte_len(keycolon), - str::byte_len(line)); - log #fmt("%s: %s", directive, value); + istr::slice(line, colon + istr::byte_len(keycolon), + istr::byte_len(line)); + log #fmt("%s: %s", + istr::to_estr(directive), + istr::to_estr(value)); option::some(value) } else { option::none } } diff --git a/src/test/compiletest/procsrv.rs b/src/test/compiletest/procsrv.rs index abe40b7a327..3fb2bfc3700 100644 --- a/src/test/compiletest/procsrv.rs +++ b/src/test/compiletest/procsrv.rs @@ -54,12 +54,12 @@ fn close(handle: &handle) { task::join(option::get(handle.task)); } -fn run(handle: &handle, lib_path: &str, prog: &str, args: &[str], - input: &option::t) -> {status: int, out: str, err: str} { +fn run(handle: &handle, lib_path: &istr, prog: &istr, args: &[istr], + input: &option::t) -> {status: int, out: istr, err: istr} { let p = port(); let ch = chan(p); send(handle.chan, - exec(str::bytes(lib_path), str::bytes(prog), clone_vecstr(args), + exec(istr::bytes(lib_path), istr::bytes(prog), clone_vecstr(args), ch)); let resp = recv(p); @@ -70,23 +70,23 @@ fn run(handle: &handle, lib_path: &str, prog: &str, args: &[str], ret {status: status, out: output, err: errput}; } -fn writeclose(fd: int, s: &option::t) { +fn writeclose(fd: int, s: &option::t) { if option::is_some(s) { let writer = io::new_writer(io::fd_buf_writer(fd, option::none)); - writer.write_str(istr::from_estr(option::get(s))); + writer.write_str(option::get(s)); } os::libc::close(fd); } -fn readclose(fd: int) -> str { +fn readclose(fd: int) -> istr { // Copied from run::program_output let file = os::fd_FILE(fd); let reader = io::new_reader(io::FILE_buf_reader(file, option::none)); - let buf = ""; + let buf = ~""; while !reader.eof() { let bytes = reader.read_bytes(4096u); - buf += str::unsafe_from_bytes(bytes); + buf += istr::unsafe_from_bytes(bytes); } os::libc::fclose(file); ret buf; @@ -115,8 +115,8 @@ fn worker(p: port) { // the alt discriminant are wrong. alt recv(p) { exec(lib_path, prog, args, respchan) { - {lib_path: str::unsafe_from_bytes(lib_path), - prog: str::unsafe_from_bytes(prog), + {lib_path: istr::unsafe_from_bytes(lib_path), + prog: istr::unsafe_from_bytes(prog), args: clone_vecu8str(args), respchan: respchan} } @@ -129,8 +129,8 @@ fn worker(p: port) { let pipe_out = os::pipe(); let pipe_err = os::pipe(); let spawnproc = - bind run::spawn_process(istr::from_estr(execparms.prog), - istr::from_estrs(execparms.args), + bind run::spawn_process(execparms.prog, + execparms.args, pipe_in.in, pipe_out.out, pipe_err.out); let pid = with_lib_path(execparms.lib_path, spawnproc); @@ -152,35 +152,37 @@ fn worker(p: port) { } } -fn with_lib_path<@T>(path: &str, f: fn() -> T) -> T { - let maybe_oldpath = getenv(istr::from_estr(util::lib_path_env_var())); +fn with_lib_path<@T>(path: &istr, f: fn() -> T) -> T { + let maybe_oldpath = getenv(util::lib_path_env_var()); append_lib_path(path); let res = f(); if option::is_some(maybe_oldpath) { - export_lib_path(istr::to_estr(option::get(maybe_oldpath))); + export_lib_path(option::get(maybe_oldpath)); } else { // FIXME: This should really be unset but we don't have that yet - export_lib_path(""); + export_lib_path(~""); } ret res; } -fn append_lib_path(path: &str) { export_lib_path(util::make_new_path(path)); } - -fn export_lib_path(path: &str) { - setenv(istr::from_estr(util::lib_path_env_var()), istr::from_estr(path)); +fn append_lib_path(path: &istr) { + export_lib_path(util::make_new_path(path)); } -fn clone_vecstr(v: &[str]) -> [[u8]] { +fn export_lib_path(path: &istr) { + setenv(util::lib_path_env_var(), path); +} + +fn clone_vecstr(v: &[istr]) -> [[u8]] { let r = []; - for t: str in vec::slice(v, 0u, vec::len(v)) { r += [str::bytes(t)]; } + for t: istr in vec::slice(v, 0u, vec::len(v)) { r += [istr::bytes(t)]; } ret r; } -fn clone_vecu8str(v: &[[u8]]) -> [str] { +fn clone_vecu8str(v: &[[u8]]) -> [istr] { let r = []; for t in vec::slice(v, 0u, vec::len(v)) { - r += [str::unsafe_from_bytes(t)]; + r += [istr::unsafe_from_bytes(t)]; } ret r; } diff --git a/src/test/compiletest/runtest.rs b/src/test/compiletest/runtest.rs index 314f9677437..3192e168c57 100644 --- a/src/test/compiletest/runtest.rs +++ b/src/test/compiletest/runtest.rs @@ -20,12 +20,12 @@ import util::logv; export run; fn run(cx: &cx, _testfile: -[u8]) { - let testfile = str::unsafe_from_bytes(_testfile); + let testfile = istr::unsafe_from_bytes(_testfile); if cx.config.verbose { // We're going to be dumping a lot of info. Start on a new line. io::stdout().write_str(~"\n\n"); } - log #fmt["running %s", testfile]; + log #fmt["running %s", istr::to_estr(testfile)]; let props = load_props(testfile); alt cx.config.mode { mode_compile_fail. { run_cfail_test(cx, props, testfile); } @@ -35,25 +35,25 @@ fn run(cx: &cx, _testfile: -[u8]) { } } -fn run_cfail_test(cx: &cx, props: &test_props, testfile: &str) { +fn run_cfail_test(cx: &cx, props: &test_props, testfile: &istr) { let procres = compile_test(cx, props, testfile); if procres.status == 0 { - fatal_procres("compile-fail test compiled successfully!", procres); + fatal_procres(~"compile-fail test compiled successfully!", procres); } check_error_patterns(props, testfile, procres); } -fn run_rfail_test(cx: &cx, props: &test_props, testfile: &str) { +fn run_rfail_test(cx: &cx, props: &test_props, testfile: &istr) { let procres = compile_test(cx, props, testfile); - if procres.status != 0 { fatal_procres("compilation failed!", procres); } + if procres.status != 0 { fatal_procres(~"compilation failed!", procres); } procres = exec_compiled_test(cx, props, testfile); if procres.status == 0 { - fatal_procres("run-fail test didn't produce an error!", procres); + fatal_procres(~"run-fail test didn't produce an error!", procres); } // This is the value valgrind returns on failure @@ -62,42 +62,44 @@ fn run_rfail_test(cx: &cx, props: &test_props, testfile: &str) { // exit code on the command-line (137)? const valgrind_err: int = 9; if procres.status == valgrind_err { - fatal_procres("run-fail test isn't valgrind-clean!", procres); + fatal_procres(~"run-fail test isn't valgrind-clean!", procres); } check_error_patterns(props, testfile, procres); } -fn run_rpass_test(cx: &cx, props: &test_props, testfile: &str) { +fn run_rpass_test(cx: &cx, props: &test_props, testfile: &istr) { let procres = compile_test(cx, props, testfile); - if procres.status != 0 { fatal_procres("compilation failed!", procres); } + if procres.status != 0 { fatal_procres(~"compilation failed!", procres); } procres = exec_compiled_test(cx, props, testfile); - if procres.status != 0 { fatal_procres("test run failed!", procres); } + if procres.status != 0 { fatal_procres(~"test run failed!", procres); } } -fn run_pretty_test(cx: &cx, props: &test_props, testfile: &str) { +fn run_pretty_test(cx: &cx, props: &test_props, testfile: &istr) { if option::is_some(props.pp_exact) { - logv(cx.config, "testing for exact pretty-printing"); - } else { logv(cx.config, "testing for converging pretty-printing"); } + logv(cx.config, ~"testing for exact pretty-printing"); + } else { logv(cx.config, ~"testing for converging pretty-printing"); } let rounds = alt props.pp_exact { option::some(_) { 1 } option::none. { 2 } }; - let srcs = [istr::to_estr(io::read_whole_file_str( - istr::from_estr(testfile)))]; + let srcs = [io::read_whole_file_str(testfile)]; let round = 0; while round < rounds { - logv(cx.config, #fmt["pretty-printing round %d", round]); + logv(cx.config, + istr::from_estr(#fmt["pretty-printing round %d", round])); let procres = print_source(cx, testfile, srcs[round]); if procres.status != 0 { - fatal_procres(#fmt["pretty-printing failed in round %d", round], - procres); + fatal_procres( + istr::from_estr(#fmt["pretty-printing failed in round %d", + round]), + procres); } srcs += [procres.stdout]; @@ -107,9 +109,8 @@ fn run_pretty_test(cx: &cx, props: &test_props, testfile: &str) { let expected = alt props.pp_exact { option::some(file) { - let filepath = fs::connect(fs::dirname( - istr::from_estr(testfile)), istr::from_estr(file)); - istr::to_estr(io::read_whole_file_str(filepath)) + let filepath = fs::connect(fs::dirname(testfile), file); + io::read_whole_file_str(filepath) } option::none. { srcs[vec::len(srcs) - 2u] } }; @@ -117,10 +118,10 @@ fn run_pretty_test(cx: &cx, props: &test_props, testfile: &str) { if option::is_some(props.pp_exact) { // Now we have to care about line endings - let cr = "\r"; - check (str::is_not_empty(cr)); - actual = str::replace(actual, cr, ""); - expected = str::replace(expected, cr, ""); + let cr = ~"\r"; + check (istr::is_not_empty(cr)); + actual = istr::replace(actual, cr, ~""); + expected = istr::replace(expected, cr, ~""); } compare_source(expected, actual); @@ -129,25 +130,25 @@ fn run_pretty_test(cx: &cx, props: &test_props, testfile: &str) { let procres = typecheck_source(cx, testfile, actual); if procres.status != 0 { - fatal_procres("pretty-printed source does not typecheck", procres); + fatal_procres(~"pretty-printed source does not typecheck", procres); } ret; - fn print_source(cx: &cx, testfile: &str, src: &str) -> procres { + fn print_source(cx: &cx, testfile: &istr, src: &istr) -> procres { compose_and_run(cx, testfile, make_pp_args, cx.config.compile_lib_path, option::some(src)) } - fn make_pp_args(config: &config, _testfile: &str) -> procargs { - let prog = istr::to_estr(config.rustc_path); - let args = ["-", "--pretty", "normal"]; + fn make_pp_args(config: &config, _testfile: &istr) -> procargs { + let prog = config.rustc_path; + let args = [~"-", ~"--pretty", ~"normal"]; ret {prog: prog, args: args}; } - fn compare_source(expected: &str, actual: &str) { + fn compare_source(expected: &istr, actual: &istr) { if expected != actual { - error("pretty-printed source does match expected source"); + error(~"pretty-printed source does match expected source"); let msg = #fmt["\n\ expected:\n\ @@ -159,39 +160,39 @@ actual:\n\ %s\n\ ------------------------------------------\n\ \n", - expected, actual]; + istr::to_estr(expected), istr::to_estr(actual)]; io::stdout().write_str(istr::from_estr(msg)); fail; } } - fn typecheck_source(cx: &cx, testfile: &str, src: &str) -> procres { + fn typecheck_source(cx: &cx, testfile: &istr, src: &istr) -> procres { compose_and_run(cx, testfile, make_typecheck_args, cx.config.compile_lib_path, option::some(src)) } - fn make_typecheck_args(config: &config, _testfile: &str) -> procargs { - let prog = istr::to_estr(config.rustc_path); - let args = ["-", "--no-trans", "--lib"]; + fn make_typecheck_args(config: &config, _testfile: &istr) -> procargs { + let prog = config.rustc_path; + let args = [~"-", ~"--no-trans", ~"--lib"]; ret {prog: prog, args: args}; } } -fn check_error_patterns(props: &test_props, testfile: &str, +fn check_error_patterns(props: &test_props, testfile: &istr, procres: &procres) { if vec::is_empty(props.error_patterns) { - fatal("no error pattern specified in " + testfile); + fatal(~"no error pattern specified in " + testfile); } if procres.status == 0 { - fatal("process did not return an error status"); + fatal(~"process did not return an error status"); } let next_err_idx = 0u; let next_err_pat = props.error_patterns[next_err_idx]; - for line: str in str::split(procres.stdout, '\n' as u8) { - if str::find(line, next_err_pat) > 0 { - log #fmt["found error pattern %s", next_err_pat]; + for line: istr in istr::split(procres.stdout, '\n' as u8) { + if istr::find(line, next_err_pat) > 0 { + log #fmt["found error pattern %s", istr::to_estr(next_err_pat)]; next_err_idx += 1u; if next_err_idx == vec::len(props.error_patterns) { log "found all error patterns"; @@ -205,45 +206,49 @@ fn check_error_patterns(props: &test_props, testfile: &str, vec::slice(props.error_patterns, next_err_idx, vec::len(props.error_patterns)); if vec::len(missing_patterns) == 1u { - fatal_procres(#fmt["error pattern '%s' not found!", - missing_patterns[0]], procres); + fatal_procres(istr::from_estr( + #fmt["error pattern '%s' not found!", + istr::to_estr(missing_patterns[0])]), procres); } else { - for pattern: str in missing_patterns { - error(#fmt["error pattern '%s' not found!", pattern]); + for pattern: istr in missing_patterns { + error(istr::from_estr( + #fmt["error pattern '%s' not found!", + istr::to_estr(pattern)])); } - fatal_procres("multiple error patterns not found", procres); + fatal_procres(~"multiple error patterns not found", procres); } } -type procargs = {prog: str, args: [str]}; +type procargs = {prog: istr, args: [istr]}; -type procres = {status: int, stdout: str, stderr: str, cmdline: str}; +type procres = {status: int, stdout: istr, stderr: istr, cmdline: istr}; -fn compile_test(cx: &cx, props: &test_props, testfile: &str) -> procres { +fn compile_test(cx: &cx, props: &test_props, testfile: &istr) -> procres { compose_and_run(cx, testfile, bind make_compile_args(_, props, _), cx.config.compile_lib_path, option::none) } -fn exec_compiled_test(cx: &cx, props: &test_props, testfile: &str) -> +fn exec_compiled_test(cx: &cx, props: &test_props, testfile: &istr) -> procres { compose_and_run(cx, testfile, bind make_run_args(_, props, _), cx.config.run_lib_path, option::none) } -fn compose_and_run(cx: &cx, testfile: &str, - make_args: fn(&config, &str) -> procargs, lib_path: &istr, - input: option::t) -> procres { +fn compose_and_run(cx: &cx, testfile: &istr, + make_args: fn(&config, &istr) -> procargs, + lib_path: &istr, + input: option::t) -> procres { let procargs = make_args(cx.config, testfile); ret program_output(cx, testfile, lib_path, procargs.prog, procargs.args, input); } -fn make_compile_args(config: &config, props: &test_props, testfile: &str) -> +fn make_compile_args(config: &config, props: &test_props, testfile: &istr) -> procargs { - let prog = istr::to_estr(config.rustc_path); - let args = [testfile, "-o", make_exe_name(config, testfile)]; + let prog = config.rustc_path; + let args = [testfile, ~"-o", make_exe_name(config, testfile)]; let rustcflags = alt config.rustcflags { - option::some(s) { option::some(istr::to_estr(s)) } + option::some(s) { option::some(s) } option::none. { option::none } }; args += split_maybe_args(rustcflags); @@ -251,17 +256,17 @@ fn make_compile_args(config: &config, props: &test_props, testfile: &str) -> ret {prog: prog, args: args}; } -fn make_exe_name(config: &config, testfile: &str) -> str { - output_base_name(config, testfile) + istr::to_estr(os::exec_suffix()) +fn make_exe_name(config: &config, testfile: &istr) -> istr { + output_base_name(config, testfile) + os::exec_suffix() } -fn make_run_args(config: &config, props: &test_props, testfile: &str) -> +fn make_run_args(config: &config, props: &test_props, testfile: &istr) -> procargs { let toolargs = if !props.no_valgrind { // If we've got another tool to run under (valgrind), // then split apart its command let runtool = alt config.runtool { - option::some(s) { option::some(istr::to_estr(s)) } + option::some(s) { option::some(s) } option::none. { option::none } }; split_maybe_args(runtool) @@ -271,14 +276,14 @@ fn make_run_args(config: &config, props: &test_props, testfile: &str) -> ret {prog: args[0], args: vec::slice(args, 1u, vec::len(args))}; } -fn split_maybe_args(argstr: &option::t) -> [str] { - fn rm_whitespace(v: &[str]) -> [str] { - fn flt(s: &str) -> option::t { +fn split_maybe_args(argstr: &option::t) -> [istr] { + fn rm_whitespace(v: &[istr]) -> [istr] { + fn flt(s: &istr) -> option::t { if !is_whitespace(s) { option::some(s) } else { option::none } } // FIXME: This should be in std - fn is_whitespace(s: str) -> bool { + fn is_whitespace(s: &istr) -> bool { for c: u8 in s { if c != ' ' as u8 { ret false; } } ret true; } @@ -286,18 +291,19 @@ fn split_maybe_args(argstr: &option::t) -> [str] { } alt argstr { - option::some(s) { rm_whitespace(str::split(s, ' ' as u8)) } + option::some(s) { rm_whitespace(istr::split(s, ' ' as u8)) } option::none. { [] } } } -fn program_output(cx: &cx, testfile: &str, lib_path: &istr, prog: &str, - args: &[str], input: option::t) -> procres { - let lib_path = istr::to_estr(lib_path); +fn program_output(cx: &cx, testfile: &istr, lib_path: &istr, prog: &istr, + args: &[istr], input: option::t) -> procres { let cmdline = { let cmdline = make_cmdline(lib_path, prog, args); - logv(cx.config, #fmt["executing %s", cmdline]); + logv(cx.config, + istr::from_estr(#fmt["executing %s", + istr::to_estr(cmdline)])); cmdline }; let res = procsrv::run(cx.procsrv, lib_path, prog, args, input); @@ -308,76 +314,83 @@ fn program_output(cx: &cx, testfile: &str, lib_path: &istr, prog: &str, cmdline: cmdline}; } -fn make_cmdline(libpath: &str, prog: &str, args: &[str]) -> str { - #fmt["%s %s %s", lib_path_cmd_prefix(libpath), prog, - str::connect(args, " ")] +fn make_cmdline(libpath: &istr, prog: &istr, args: &[istr]) -> istr { + istr::from_estr(#fmt["%s %s %s", + istr::to_estr(lib_path_cmd_prefix(libpath)), + istr::to_estr(prog), + istr::to_estr(istr::connect(args, ~" "))]) } // Build the LD_LIBRARY_PATH variable as it would be seen on the command line // for diagnostic purposes -fn lib_path_cmd_prefix(path: &str) -> str { - #fmt["%s=\"%s\"", util::lib_path_env_var(), util::make_new_path(path)] +fn lib_path_cmd_prefix(path: &istr) -> istr { + istr::from_estr(#fmt["%s=\"%s\"", + istr::to_estr(util::lib_path_env_var()), + istr::to_estr(util::make_new_path(path))]) } -fn dump_output(config: &config, testfile: &str, out: &str, err: &str) { - dump_output_file(config, testfile, out, "out"); - dump_output_file(config, testfile, err, "err"); +fn dump_output(config: &config, testfile: &istr, out: &istr, err: &istr) { + dump_output_file(config, testfile, out, ~"out"); + dump_output_file(config, testfile, err, ~"err"); maybe_dump_to_stdout(config, out, err); } #[cfg(target_os = "win32")] #[cfg(target_os = "linux")] -fn dump_output_file(config: &config, testfile: &str, out: &str, - extension: &str) { +fn dump_output_file(config: &config, testfile: &istr, out: &istr, + extension: &istr) { let outfile = make_out_name(config, testfile, extension); - let writer = io::file_writer(istr::from_estr(outfile), + let writer = io::file_writer(outfile, [io::create, io::truncate]); - writer.write_str(istr::from_estr(out)); + writer.write_str(out); } // FIXME (726): Can't use file_writer on mac #[cfg(target_os = "macos")] -fn dump_output_file(config: &config, testfile: &str, out: &str, - extension: &str) { +fn dump_output_file(config: &config, testfile: &istr, out: &istr, + extension: &istr) { } -fn make_out_name(config: &config, testfile: &str, extension: &str) -> str { - output_base_name(config, testfile) + "." + extension +fn make_out_name(config: &config, testfile: &istr, + extension: &istr) -> istr { + output_base_name(config, testfile) + ~"." + extension } -fn output_base_name(config: &config, testfile: &str) -> str { - let base = istr::to_estr(config.build_base); +fn output_base_name(config: &config, testfile: &istr) -> istr { + let base = config.build_base; let filename = { - let parts = istr::split(fs::basename(istr::from_estr(testfile)), + let parts = istr::split(fs::basename(testfile), '.' as u8); parts = vec::slice(parts, 0u, vec::len(parts) - 1u); istr::connect(parts, ~".") }; - #fmt["%s%s.%s", base, istr::to_estr(filename), - istr::to_estr(config.stage_id)] + istr::from_estr(#fmt["%s%s.%s", istr::to_estr(base), + istr::to_estr(filename), + istr::to_estr(config.stage_id)]) } -fn maybe_dump_to_stdout(config: &config, out: &str, err: &str) { +fn maybe_dump_to_stdout(config: &config, out: &istr, err: &istr) { if config.verbose { let sep1 = #fmt["------%s------------------------------", "stdout"]; let sep2 = #fmt["------%s------------------------------", "stderr"]; - let sep3 = "------------------------------------------"; + let sep3 = ~"------------------------------------------"; io::stdout().write_line(istr::from_estr(sep1)); - io::stdout().write_line(istr::from_estr(out)); + io::stdout().write_line(out); io::stdout().write_line(istr::from_estr(sep2)); - io::stdout().write_line(istr::from_estr(err)); - io::stdout().write_line(istr::from_estr(sep3)); + io::stdout().write_line(err); + io::stdout().write_line(sep3); } } -fn error(err: &str) { - io::stdout().write_line(istr::from_estr(#fmt["\nerror: %s", err])); +fn error(err: &istr) { + io::stdout().write_line(istr::from_estr(#fmt["\nerror: %s", + istr::to_estr(err)])); } -fn fatal(err: &str) -> ! { error(err); fail; } +fn fatal(err: &istr) -> ! { error(err); fail; } -fn fatal_procres(err: &str, procres: procres) -> ! { +fn fatal_procres(err: &istr, procres: procres) -> ! { let msg = istr::from_estr(#fmt["\n\ error: %s\n\ @@ -391,7 +404,10 @@ stderr:\n\ %s\n\ ------------------------------------------\n\ \n", - err, procres.cmdline, procres.stdout, procres.stderr]); + istr::to_estr(err), + istr::to_estr(procres.cmdline), + istr::to_estr(procres.stdout), + istr::to_estr(procres.stderr)]); io::stdout().write_str(msg); fail; } diff --git a/src/test/compiletest/util.rs b/src/test/compiletest/util.rs index 2aa313e29a1..e979c177a47 100644 --- a/src/test/compiletest/util.rs +++ b/src/test/compiletest/util.rs @@ -5,28 +5,30 @@ import std::istr; import common::config; -fn make_new_path(path: &str) -> str { +fn make_new_path(path: &istr) -> istr { // Windows just uses PATH as the library search path, so we have to // maintain the current value while adding our own - alt getenv(istr::from_estr(lib_path_env_var())) { - option::some(curr) { #fmt["%s:%s", path, istr::to_estr(curr)] } + alt getenv(lib_path_env_var()) { + option::some(curr) { + istr::from_estr(#fmt["%s:%s", + istr::to_estr(path), istr::to_estr(curr)]) } option::none. { path } } } #[cfg(target_os = "linux")] -fn lib_path_env_var() -> str { "LD_LIBRARY_PATH" } +fn lib_path_env_var() -> istr { ~"LD_LIBRARY_PATH" } #[cfg(target_os = "macos")] -fn lib_path_env_var() -> str { "DYLD_LIBRARY_PATH" } +fn lib_path_env_var() -> istr { ~"DYLD_LIBRARY_PATH" } #[cfg(target_os = "win32")] -fn lib_path_env_var() -> str { "PATH" } +fn lib_path_env_var() -> istr { "PATH" } -fn logv(config: &config, s: &str) { +fn logv(config: &config, s: &istr) { log s; if config.verbose { - io::stdout().write_line(std::istr::from_estr(s)); + io::stdout().write_line(s); } }