SteppedHWIOTester

abstract val device_under_test: Module

final def !=(arg0: Any): Boolean

final def ##(): Int

def <>(src: Module): Unit

Connect io with matching names for two modules

final def ==(arg0: Any): Boolean

def IO[T <: Data](iodef: T): iodef.type

var _clock: Option[Clock]

def addClock(clock: Clock): Unit

Add a clock to the module

def addDefaultReset: Unit

Add a default reset to the module

def addModule[T <: Module](c: ⇒ T)(implicit p: Parameters = params): T

Add a submodule to this module

def addModule[T <: Module](c: ⇒ T, f: PartialFunction[Any, Any]): T

Add a submodule to this module

def addNode[T <: Node](node: T): T

def addPin[T <: Data](pin: T, name: String = ""): T

Add a pin with a name to the module

def addResetPin(r: Bool): Bool

def apply(name: String): Data

final def asInstanceOf[T0]: T0

def assert(cond: Bool, message: String = ""): Unit

Add an assertion in the code generated by a backend.

def bfs(visit: (Node) ⇒ Unit): Unit

A breadth first search of the graph of nodes

val children: ArrayBuffer[Module]

def clock: Clock

def clone(): AnyRef

def createVectorsAndTestsForOutput(output_port: Data, counter: Counter): Unit

def createVectorsForInput(input_port: Data, counter: Counter): Unit

def debug(data: Aggregate): Unit

def debug(x: Node): Unit

Insures a backend does not remove a signal because it is unreachable from the outputs.

def dfs(visit: (Node) ⇒ Unit): Unit

A depth first search of the graph of nodes

var enable_all_debug: Boolean

var enable_printf_debug: Boolean

var enable_scala_debug: Boolean

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def error(message: String = ""): Unit

def expect(io_port: Data, bool_value: Boolean): Unit

def expect(io_port: Data, value: BigInt): Unit

def finalize(): Unit

def findBinding(m: Node): Option[Binding]

A method to trace the graph of nodes backwards looking at inputs

def finish(): Unit

final def getClass(): Class[_]

def getPathName(separator: String = "_"): String

def getPathName: String

val hashCode: Int

def int(x: Bits): BigInt

val io: Bundle { ... /* 4 definitions in type refinement */ }

the I/O for this module

var io_info: IOAccessor

final def isInstanceOf[T0]: Boolean

def logPrintfDebug(fmt: String, args: Bits*): Unit

def logScalaDebug(msg: ⇒ String): Unit

var moduleName: String

Name of the module this component generates (defaults to class name).

var name: String

Name of the instance.

var named: Boolean

named is used to indicate that name was set explicitly and should not be overriden

final def ne(arg0: AnyRef): Boolean

def nextIndex: Int

final def notify(): Unit

final def notifyAll(): Unit

lazy val params: Parameters

var parent: Module

def poke(io_port: Data, value: BigInt): Unit

def popCount(n: Long): Int

def printf(message: String, args: Node*): Unit

Adds a printf to the module called each clock cycle

def reset: Bool

val rnd: Random

val setDone: Bool

val setError: Bool

def setModuleName(n: String): Unit

Set the declaration name of the module to be string 'n'

def setName(n: String): Unit

Set the name of this module to the string 'n'

def step(number_of_cycles: Int): Unit

def stop(): Unit

Ends the test reporting success.

def stripComponent(s: String): String

final def synchronized[T0](arg0: ⇒ T0): T0

val test_actions: ArrayBuffer[Step]

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def wires: Array[(String, Bits)]

Get the I/O names and connections