First cut at refactoring unittests into a top-level utility. Individual tests co-located with their DUT. No functional changes.

src/main/scala/unittest/TempListOfTests.scala

@@ -0,0 +1,21 @@
+package unittest
+
+import Chisel._
+import cde.Parameters
+
+object JunctionsUnitTests {
+  def apply(implicit p: Parameters): Seq[UnitTest] =
+    Seq(
+      Module(new junctions.MultiWidthFifoTest),
+      Module(new junctions.NastiMemoryDemuxTest),
+      Module(new junctions.HastiTest))
+}
+
+object UncoreUnitTests {
+  def apply(implicit p: Parameters): Seq[UnitTest] =
+    Seq(
+      Module(new uncore.converters.SmiConverterTest),
+      Module(new uncore.devices.ROMSlaveTest),
+      Module(new uncore.devices.TileLinkRAMTest),
+      Module(new uncore.tilelink2.TLFuzzRAMTest))
+}

src/main/scala/unittest/UnitTest.scala

@@ -0,0 +1,58 @@
+package unittest
+
+import Chisel._
+import cde.{Field, Parameters}
+import util.Timer
+
+trait HasUnitTestIO {
+  val io = new Bundle {
+    val finished = Bool(OUTPUT)
+    val start = Bool(INPUT)
+  }
+}
+
+abstract class UnitTest extends Module with HasUnitTestIO {
+  when (io.start) {
+    printf(s"Started UnitTest ${this.getClass.getSimpleName}\n")
+  }
+}
+
+case object UnitTests extends Field[Parameters => Seq[UnitTest]]
+
+class UnitTestSuite(implicit p: Parameters) extends Module {
+  val io = new Bundle {
+    val finished = Bool(OUTPUT)
+  }
+
+  val tests = p(UnitTests)(p)
+
+  val s_idle :: s_start :: s_wait :: s_done :: Nil = Enum(Bits(), 4)
+  val state = Reg(init = s_idle)
+  val test_idx = Reg(init = UInt(0, log2Up(tests.size)))
+  val test_finished = Vec(tests.map(_.io.finished))
+
+  when (state === s_idle) { state := s_start }
+  when (state === s_start) { state := s_wait }
+  when (state === s_wait && test_finished(test_idx)) {
+    state := s_start
+    test_idx := test_idx + UInt(1)
+    state := Mux(test_idx === UInt(tests.size - 1), s_done, s_start)
+  }
+
+  val timer = Module(new Timer(500000, tests.size))
+  timer.io.start.valid := Bool(false)
+  timer.io.stop.valid := Bool(false)
+
+  tests.zipWithIndex.foreach { case (mod, i) =>
+    mod.io.start := (state === s_start) && test_idx === UInt(i)
+    when (test_idx === UInt(i)) {
+      timer.io.start.valid := mod.io.start
+      timer.io.start.bits := UInt(i)
+      timer.io.stop.valid := mod.io.finished
+      timer.io.stop.bits := UInt(i)
+    }
+  }
+  io.finished := (state === s_done)
+
+  assert(!timer.io.timeout.valid, "UnitTest timed out")
+}