---

yaml
---
r: 5059
b: refs/heads/master
c: 4007006
h: refs/heads/master
i:
  5057: 4e1428c
  5055: 749fb47
v: v3

Author: brson

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: eb70267e5e731a5b489aabf0e2214a9c4a264e26
+refs/heads/master: 4007006574561280139659a42000321020d589ff

trunk/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,36 +72,49 @@ 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<istr>) -> str {
+fn opt_str(maybestr: option::t<istr>) -> istr {
     alt maybestr {
-      option::some(s) { istr::to_estr(s) }
-      option::none. { "(none)" }
+      option::some(s) { s }
+      option::none. { ~"(none)" }
     }
 }
 
 fn str_opt(maybestr: &istr) -> option::t<istr> {
     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,23 +158,22 @@ 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)];
         }
     }
     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),

trunk/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<str>,
+    compile_flags: option::t<istr>,
     // If present, the name of a file that this test should match when
     // pretty-printed
-    pp_exact: option::t<str>,
+    pp_exact: option::t<istr>,
     // 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,70 +55,72 @@ 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<str> {
-    parse_name_value_directive(line, "error-pattern")
+fn parse_error_pattern(line: &istr) -> option::t<istr> {
+    parse_name_value_directive(line, ~"error-pattern")
 }
 
-fn parse_compile_flags(line: &str) -> option::t<str> {
-    parse_name_value_directive(line, "compile-flags")
+fn parse_compile_flags(line: &istr) -> option::t<istr> {
+    parse_name_value_directive(line, ~"compile-flags")
 }
 
-fn parse_pp_exact(line: &str, testfile: &str) -> option::t<str> {
-    alt parse_name_value_directive(line, "pp-exact") {
+fn parse_pp_exact(line: &istr, testfile: &istr) -> option::t<istr> {
+    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
         }
       }
     }
 }
 
-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<str> {
-    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<istr> {
+    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 }
 }