class
MapTester[+T <: Module] extends Tester[T]
Instance Constructors
-
new
MapTester(c: T, testNodes: Array[Node])
Value Members
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
final
def
==(arg0: AnyRef): Boolean
-
final
def
==(arg0: Any): Boolean
-
def
addPoke(snaps: ArrayBuffer[Snapshot], now: Int, poke: Poke): ArrayBuffer[_ >: Poke with Snapshot <: AnyRef]
-
final
def
asInstanceOf[T0]: T0
-
def
checkForPokes(start: Int, target: Int): Unit
-
def
clone(): AnyRef
-
def
createOutputFile(name: String): FileWriter
-
def
defTests(body: ⇒ Boolean): Boolean
-
var
delta: Int
-
def
doPokeBits(data: Node, x: BigInt, off: Int = 1): Unit
-
-
def
dumpName(data: Node): String
-
def
dumpSnapshots(filename: String, snapshots: ArrayBuffer[Snapshot]): Unit
-
def
emulatorCmd(str: String): String
-
def
ensureDir(dir: String): String
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(arg0: Any): Boolean
-
def
expect(data: Aggregate, expected: Array[BigInt]): Boolean
-
def
expect(data: Bits, expected: BigInt): Boolean
-
def
expect(good: Boolean, msg: String): Boolean
-
var
failureTime: Int
-
def
finalize(): Unit
-
def
findSnapshotIndex(snaps: ArrayBuffer[Snapshot], target: Int): Int
-
def
finish(): Boolean
-
final
def
getClass(): Class[_]
-
def
goto(target: Int): Unit
-
def
hashCode(): Int
-
val
ins: Seq[Node]
-
def
int(x: Bits): BigInt
-
def
int(x: Int): BigInt
-
def
int(x: Boolean): BigInt
-
final
def
isInstanceOf[T0]: Boolean
-
val
isLoggingPokes: Boolean
-
val
isSnapshotting: Boolean
-
val
isTrace: Boolean
-
def
load(s: Snapshot): Unit
-
def
loadPokes(filename: String): Unit
-
def
loadSnapshots(filename: String): ArrayBuffer[Snapshot]
-
def
loadSnapshotsInto(filename: String, snaps: ArrayBuffer[Snapshot]): ArrayBuffer[Snapshot]
-
val
mappings: HashMap[String, Node]
-
val
mems: ArrayBuffer[Node]
-
final
def
ne(arg0: AnyRef): Boolean
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
var
ok: Boolean
-
val
outs: Seq[Node]
-
def
peek(data: Aggregate): Array[BigInt]
-
def
peek(data: Bits): BigInt
-
def
peekAt[T <: Bits](data: Mem[T], off: Int): BigInt
-
def
peekBits(data: Node, off: Int = 1): BigInt
-
def
poke(data: Aggregate, x: Array[BigInt]): Unit
-
def
poke(data: Bits, x: BigInt): Unit
-
def
pokeAt[T <: Bits](data: Mem[T], x: BigInt, off: Int): Unit
-
def
pokeBits(data: Node, x: BigInt, off: Int = 1): Unit
-
val
pokez: ArrayBuffer[Snapshot]
-
var
process: Process
-
def
puts(str: String): Unit
-
val
regs: ArrayBuffer[Node]
-
def
reset(n: Int = 1): Unit
-
val
rnd: Random
-
val
sb: StringBuilder
-
def
setClocks(clocks: HashMap[Clock, Int]): Unit
-
-
val
snapshots: ArrayBuffer[Snapshot]
-
def
splitFlattenNodes(args: Seq[Node]): (Seq[Node], Seq[Node])
-
def
start(): Process
-
def
step(svars: HashMap[Node, Node], ovars: HashMap[Node, Node] = new HashMap[Node, Node], isTrace: Boolean = true): Boolean
-
def
step(n: Int): Unit
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
var
t: Int
-
var
testErr: InputStream
-
var
testIn: InputStream
-
val
testInputNodes: Array[Node]
-
val
testNodes: Array[Node]
-
val
testNonInputNodes: Array[Node]
-
var
testOut: OutputStream
-
var
tests: () ⇒ Boolean
-
def
toString(): String
-
def
unstep(n: Int): Unit
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
def
waitForStreams(): Unit
Inherited from AnyRef
Inherited from Any
