Add simple API for generating testharnesses inline

src/main/scala/chisel3/experimental/inlinetest/package.scala

@@ -0,0 +1,80 @@
+package chisel3.experimental.inlinetest
+
+import chisel3._
+import chisel3.experimental.hierarchy.{Definition, Instance}
+
+/** Per-test parametrization needed to build a testharness that instantiates
+  *  the DUT and elaborates a test body.
+  *
+  *  @tparam M the type of the DUT module
+  *  @tparam R the type of the result returned by the test body
+  */
+case class TestParameters[M <: RawModule, R](
+  /** The [[desiredName]] of the DUT module. */
+  dutName: String,
+  /** The user-provided name of the test. */
+  testName: String,
+  /** A Definition of the DUT module. */
+  dutDefinition: Definition[M],
+  /** The body for this test, returns a result. */
+  body: Instance[M] => R
+)
+
+/** An implementation of a testharness generator.
+  *
+  *  @tparam M the type of the DUT module
+  *  @tparam R the type of the result returned by the test body
+  */
+trait TestHarness[M <: RawModule, R] {
+
+  /** Generate a testharness module given the test parameters. */
+  def generate(test: TestParameters[M, R]): RawModule with Public
+}
+
+object TestHarness {
+
+  /** The minimal implementation of a unit testharness. Has a clock input and a synchronous reset
+    *  input. Connects these to the DUT and does nothing else.
+    */
+  class UnitTestHarness[M <: RawModule](test: TestParameters[M, Unit]) extends Module with Public {
+    override def resetType = Module.ResetType.Synchronous
+    override val desiredName = s"test_${test.dutName}_${test.testName}"
+    val dut = Instance(test.dutDefinition)
+    test.body(dut)
+  }
+
+  implicit def unitTestHarness[M <: RawModule]: TestHarness[M, Unit] = new TestHarness[M, Unit] {
+    def generate(test: TestParameters[M, Unit]): RawModule with Public = new UnitTestHarness(test)
+  }
+}
+
+/** Provides methods to build unit testharnesses inline after this module is elaborated.
+  *
+  *  @tparam TestResult the type returned from each test body generator, typically
+  *  hardware indicating completion and/or exit code to the testharness.
+  */
+trait HasTests[M <: RawModule] { module: M =>
+
+  /** A Definition of the DUT to be used for each of the tests. */
+  private lazy val moduleDefinition =
+    module.toDefinition.asInstanceOf[Definition[module.type]]
+
+  /** Generate an additional parent around this module.
+    *
+    *  @param parent generator function, should instantiate the [[Definition]]
+    */
+  protected final def elaborateParentModule(parent: Definition[module.type] => RawModule with Public): Unit =
+    afterModuleBuilt { Definition(parent(moduleDefinition)) }
+
+  /** Generate a public module that instantiates this module. The default
+    *  testharness has clock and synchronous reset IOs and contains the test
+    *  body.
+    *
+    *  @param body the circuit to elaborate inside the testharness
+    */
+  protected final def test[R](testName: String)(body: Instance[M] => R)(implicit th: TestHarness[M, R]): Unit =
+    elaborateParentModule { moduleDefinition =>
+      val test = TestParameters[M, R](desiredName, testName, moduleDefinition, body)
+      th.generate(test)
+    }
+}

src/test/scala/chisel3/experimental/InlineTestSpec.scala

@@ -0,0 +1,100 @@
+package chiselTests
+
+import chisel3._
+import chisel3.util.Enum
+import chisel3.testers._
+import chisel3.experimental.inlinetest._
+import chisel3.experimental.hierarchy._
+
+class TestResultBundle extends Bundle {
+  val finish = Output(Bool())
+  val code = Output(UInt(8.W))
+}
+
+class TestHarnessWithResultIO[M <: RawModule](test: TestParameters[M, TestResultBundle]) extends Module {
+  override def resetType = Module.ResetType.Synchronous
+  override val desiredName = s"test_${test.dutName}_${test.testName}"
+  val dut = Instance(test.dutDefinition)
+  val result = IO(new TestResultBundle)
+  result := test.body(dut)
+}
+
+object TestHarnessWithResultIO {
+  implicit def enhancedTestHarness[M <: RawModule]: TestHarness[M, TestResultBundle] =
+    new TestHarness[M, TestResultBundle] {
+      def generate(test: TestParameters[M, TestResultBundle]): RawModule with Public =
+        new TestHarnessWithResultIO(test) with Public
+    }
+}
+
+@instantiable
+class ModuleWithTests(ioWidth: Int = 32) extends Module with HasTests[ModuleWithTests] {
+  @public val io = IO(new Bundle {
+    val in = Input(UInt(ioWidth.W))
+    val out = Output(UInt(ioWidth.W))
+  })
+
+  io.out := io.in
+
+  test("foo") { instance =>
+    instance.io.in := 3.U(ioWidth.W)
+    assert(instance.io.out === 3.U): Unit
+  }
+
+  test("bar") { instance =>
+    instance.io.in := 5.U(ioWidth.W)
+    assert(instance.io.out =/= 0.U): Unit
+  }
+
+  import TestHarnessWithResultIO._
+  test("enhanced") { instance =>
+    val result = Wire(new TestResultBundle)
+    val timer = RegInit(0.U)
+    timer := timer + 1.U
+    instance.io.in := 5.U(ioWidth.W)
+    val outValid = instance.io.out =/= 0.U
+    when(outValid) {
+      result.code := 0.U
+      result.finish := timer > 1000.U
+    }.otherwise {
+      result.code := 1.U
+      result.finish := true.B
+    }
+    result
+  }
+}
+
+class HasTestsSpec extends ChiselFlatSpec with FileCheck {
+  it should "generate a public module for each test" in {
+    generateFirrtlAndFileCheck(new ModuleWithTests)(
+      """
+      | CHECK: module ModuleWithTests
+      |
+      | CHECK: public module test_ModuleWithTests_foo
+      | CHECK: input clock : Clock
+      | CHECK: input reset : UInt<1>
+      | CHECK: inst dut of ModuleWithTests
+      |
+      | CHECK: public module test_ModuleWithTests_bar
+      | CHECK: input clock : Clock
+      | CHECK: input reset : UInt<1>
+      | CHECK: inst dut of ModuleWithTests
+      |
+      | CHECK: public module test_ModuleWithTests_enhanced
+      | CHECK: input clock : Clock
+      | CHECK: input reset : UInt<1>
+      | CHECK: output result : { finish : UInt<1>, code : UInt<8>}
+      | CHECK: inst dut of ModuleWithTests
+      """
+    )
+  }
+
+  it should "compile to verilog" in {
+    generateSystemVerilogAndFileCheck(new ModuleWithTests)(
+      """
+      | CHECK: module test_ModuleWithTests_foo
+      | CHECK: module test_ModuleWithTests_bar
+      """
+    )
+  }
+}