Run the filetests as part of "cargo test".

Refactor the filetests harness so that it can be run as part of
`cargo test`. And begin reorganizing the test harness code in preparation
for moving it out of the src directory.
 - Test subcommand files are now named `test_*.rs`.
 - cton-util subcommand files now just export their `run` and nothing else.
 - src/filetest/mod.rs now also just exports `run` and nothing else.
 - Tests are now run in release mode (with debug assertions enabled).

cranelift/src/cat.rs

@@ -3,12 +3,9 @@
 //! Read a sequence of Cretonne IL files and print them again to stdout. This has the effect of
 //! normalizing formatting and removing comments.
 
-use std::borrow::Cow;
-use cretonne::ir::Function;
-use cton_reader::{parse_functions, TestCommand};
+use cton_reader::parse_functions;
 use CommandResult;
 use utils::read_to_string;
-use filetest::subtest::{self, SubTest, Context, Result as STResult};
 
 pub fn run(files: Vec<String>) -> CommandResult {
     for (i, f) in files.into_iter().enumerate() {
@@ -37,34 +34,3 @@ fn cat_one(filename: String) -> CommandResult {
 
     Ok(())
 }
-
-/// Object implementing the `test cat` sub-test.
-///
-/// This command is used for testing the parser and function printer. It simply parses a function
-/// and prints it out again.
-///
-/// The result is verified by filecheck.
-struct TestCat;
-
-pub fn subtest(parsed: &TestCommand) -> STResult<Box<SubTest>> {
-    assert_eq!(parsed.command, "cat");
-    if !parsed.options.is_empty() {
-        Err(format!("No options allowed on {}", parsed))
-    } else {
-        Ok(Box::new(TestCat))
-    }
-}
-
-impl SubTest for TestCat {
-    fn name(&self) -> Cow<str> {
-        Cow::from("cat")
-    }
-
-    fn needs_verifier(&self) -> bool {
-        false
-    }
-
-    fn run(&self, func: Cow<Function>, context: &Context) -> STResult<()> {
-        subtest::run_filecheck(&func.display(context.isa).to_string(), context)
-    }
-}

cranelift/src/filetest/mod.rs

@@ -7,27 +7,27 @@ use std::path::Path;
 use std::time;
 use cton_reader::TestCommand;
 use CommandResult;
-use cat;
-use print_cfg;
 use filetest::runner::TestRunner;
 
-pub mod subtest;
-
-mod binemit;
-mod compile;
 mod concurrent;
-mod domtree;
-mod legalizer;
-mod licm;
-mod preopt;
-mod regalloc;
 mod runner;
 mod runone;
-mod simple_gvn;
-mod verifier;
+mod subtest;
+
+mod test_binemit;
+mod test_cat;
+mod test_compile;
+mod test_domtree;
+mod test_legalizer;
+mod test_licm;
+mod test_preopt;
+mod test_print_cfg;
+mod test_regalloc;
+mod test_simple_gvn;
+mod test_verifier;
 
 /// The result of running the test in a file.
-pub type TestResult = Result<time::Duration, String>;
+type TestResult = Result<time::Duration, String>;
 
 /// Main entry point for `cton-util test`.
 ///
@@ -59,17 +59,17 @@ pub fn run(verbose: bool, files: Vec<String>) -> CommandResult {
 /// a `.cton` test file.
 fn new_subtest(parsed: &TestCommand) -> subtest::Result<Box<subtest::SubTest>> {
     match parsed.command {
-        "binemit" => binemit::subtest(parsed),
-        "cat" => cat::subtest(parsed),
-        "compile" => compile::subtest(parsed),
-        "domtree" => domtree::subtest(parsed),
-        "legalizer" => legalizer::subtest(parsed),
-        "licm" => licm::subtest(parsed),
-        "preopt" => preopt::subtest(parsed),
-        "print-cfg" => print_cfg::subtest(parsed),
-        "regalloc" => regalloc::subtest(parsed),
-        "simple-gvn" => simple_gvn::subtest(parsed),
-        "verifier" => verifier::subtest(parsed),
+        "binemit" => test_binemit::subtest(parsed),
+        "cat" => test_cat::subtest(parsed),
+        "compile" => test_compile::subtest(parsed),
+        "domtree" => test_domtree::subtest(parsed),
+        "legalizer" => test_legalizer::subtest(parsed),
+        "licm" => test_licm::subtest(parsed),
+        "preopt" => test_preopt::subtest(parsed),
+        "print-cfg" => test_print_cfg::subtest(parsed),
+        "regalloc" => test_regalloc::subtest(parsed),
+        "simple-gvn" => test_simple_gvn::subtest(parsed),
+        "verifier" => test_verifier::subtest(parsed),
         _ => Err(format!("unknown test command '{}'", parsed.command)),
     }
 }

cranelift/src/filetest/test_cat.rs

@@ -0,0 +1,37 @@
+//! The `cat` subtest.
+
+use std::borrow::Cow;
+use cretonne::ir::Function;
+use cton_reader::TestCommand;
+use filetest::subtest::{self, SubTest, Context, Result as STResult};
+
+/// Object implementing the `test cat` sub-test.
+///
+/// This command is used for testing the parser and function printer. It simply parses a function
+/// and prints it out again.
+///
+/// The result is verified by filecheck.
+struct TestCat;
+
+pub fn subtest(parsed: &TestCommand) -> STResult<Box<SubTest>> {
+    assert_eq!(parsed.command, "cat");
+    if !parsed.options.is_empty() {
+        Err(format!("No options allowed on {}", parsed))
+    } else {
+        Ok(Box::new(TestCat))
+    }
+}
+
+impl SubTest for TestCat {
+    fn name(&self) -> Cow<str> {
+        Cow::from("cat")
+    }
+
+    fn needs_verifier(&self) -> bool {
+        false
+    }
+
+    fn run(&self, func: Cow<Function>, context: &Context) -> STResult<()> {
+        subtest::run_filecheck(&func.display(context.isa).to_string(), context)
+    }
+}

cranelift/src/filetest/test_print_cfg.rs

@@ -0,0 +1,37 @@
+//! The `print-cfg` sub-command.
+//!
+//! Read a series of Cretonne IL files and print their control flow graphs
+//! in graphviz format.
+
+use std::borrow::Cow;
+
+use cretonne::ir::Function;
+use cretonne::cfg_printer::CFGPrinter;
+use cton_reader::TestCommand;
+use filetest::subtest::{self, SubTest, Context, Result as STResult};
+
+/// Object implementing the `test print-cfg` sub-test.
+struct TestPrintCfg;
+
+pub fn subtest(parsed: &TestCommand) -> STResult<Box<SubTest>> {
+    assert_eq!(parsed.command, "print-cfg");
+    if !parsed.options.is_empty() {
+        Err(format!("No options allowed on {}", parsed))
+    } else {
+        Ok(Box::new(TestPrintCfg))
+    }
+}
+
+impl SubTest for TestPrintCfg {
+    fn name(&self) -> Cow<str> {
+        Cow::from("print-cfg")
+    }
+
+    fn needs_verifier(&self) -> bool {
+        false
+    }
+
+    fn run(&self, func: Cow<Function>, context: &Context) -> STResult<()> {
+        subtest::run_filecheck(&CFGPrinter::new(&func).to_string(), context)
+    }
+}

cranelift/src/print_cfg.rs

@@ -3,15 +3,9 @@
 //! Read a series of Cretonne IL files and print their control flow graphs
 //! in graphviz format.
 
-use std::borrow::Cow;
-use std::fmt::{Result, Write, Display, Formatter};
-
 use CommandResult;
-use cretonne::flowgraph::ControlFlowGraph;
-use cretonne::ir::Function;
-use cretonne::ir::instructions::BranchInfo;
-use cton_reader::{parse_functions, TestCommand};
-use filetest::subtest::{self, SubTest, Context, Result as STResult};
+use cretonne::cfg_printer::CFGPrinter;
+use cton_reader::parse_functions;
 use utils::read_to_string;
 
 pub fn run(files: Vec<String>) -> CommandResult {
@@ -24,72 +18,6 @@ pub fn run(files: Vec<String>) -> CommandResult {
     Ok(())
 }
 
-struct CFGPrinter<'a> {
-    func: &'a Function,
-    cfg: ControlFlowGraph,
-}
-
-impl<'a> CFGPrinter<'a> {
-    pub fn new(func: &'a Function) -> CFGPrinter<'a> {
-        CFGPrinter {
-            func,
-            cfg: ControlFlowGraph::with_function(func),
-        }
-    }
-
-    /// Write the CFG for this function to `w`.
-    pub fn write(&self, w: &mut Write) -> Result {
-        self.header(w)?;
-        self.ebb_nodes(w)?;
-        self.cfg_connections(w)?;
-        writeln!(w, "}}")
-    }
-
-    fn header(&self, w: &mut Write) -> Result {
-        writeln!(w, "digraph \"{}\" {{", self.func.name)?;
-        if let Some(entry) = self.func.layout.entry_block() {
-            writeln!(w, "    {{rank=min; {}}}", entry)?;
-        }
-        Ok(())
-    }
-
-    fn ebb_nodes(&self, w: &mut Write) -> Result {
-        for ebb in &self.func.layout {
-            write!(w, "    {} [shape=record, label=\"{{{}", ebb, ebb)?;
-            // Add all outgoing branch instructions to the label.
-            for inst in self.func.layout.ebb_insts(ebb) {
-                let idata = &self.func.dfg[inst];
-                match idata.analyze_branch(&self.func.dfg.value_lists) {
-                    BranchInfo::SingleDest(dest, _) => {
-                        write!(w, " | <{}>{} {}", inst, idata.opcode(), dest)?
-                    }
-                    BranchInfo::Table(table) => {
-                        write!(w, " | <{}>{} {}", inst, idata.opcode(), table)?
-                    }
-                    BranchInfo::NotABranch => {}
-                }
-            }
-            writeln!(w, "}}\"]")?
-        }
-        Ok(())
-    }
-
-    fn cfg_connections(&self, w: &mut Write) -> Result {
-        for ebb in &self.func.layout {
-            for (parent, inst) in self.cfg.pred_iter(ebb) {
-                writeln!(w, "    {}:{} -> {}", parent, inst, ebb)?;
-            }
-        }
-        Ok(())
-    }
-}
-
-impl<'a> Display for CFGPrinter<'a> {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        self.write(f)
-    }
-}
-
 fn print_cfg(filename: String) -> CommandResult {
     let buffer = read_to_string(&filename).map_err(
         |e| format!("{}: {}", filename, e),
@@ -107,29 +35,3 @@ fn print_cfg(filename: String) -> CommandResult {
 
     Ok(())
 }
-
-/// Object implementing the `test print-cfg` sub-test.
-struct TestPrintCfg;
-
-pub fn subtest(parsed: &TestCommand) -> STResult<Box<SubTest>> {
-    assert_eq!(parsed.command, "print-cfg");
-    if !parsed.options.is_empty() {
-        Err(format!("No options allowed on {}", parsed))
-    } else {
-        Ok(Box::new(TestPrintCfg))
-    }
-}
-
-impl SubTest for TestPrintCfg {
-    fn name(&self) -> Cow<str> {
-        Cow::from("print-cfg")
-    }
-
-    fn needs_verifier(&self) -> bool {
-        false
-    }
-
-    fn run(&self, func: Cow<Function>, context: &Context) -> STResult<()> {
-        subtest::run_filecheck(&CFGPrinter::new(&func).to_string(), context)
-    }
-}