ToyTester

Instance Constructors

new ToyTester(dut: Toy)

Type Members

class DecoupledSink[T <: Data, R] extends Processable

Definition Classes
AdvTester
class DecoupledSource[T <: Data, R] extends Processable

Definition Classes
AdvTester
class ValidSink[T <: Data, R] extends Processable

Definition Classes
AdvTester
class ValidSource[T <: Data, R] extends Processable

Definition Classes
AdvTester

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def Boolean2Int(i: Boolean): Int

Definition Classes
AdvTester
object DecoupledSink

Definition Classes
AdvTester
object DecoupledSource

Definition Classes
AdvTester
object ValidSink

Definition Classes
AdvTester
object ValidSource

Definition Classes
AdvTester
final def asInstanceOf[T0]: T0

Definition Classes
Any
def assert(expr: Boolean, errMsg: String = ""): Boolean

Definition Classes
AdvTester
val c: Toy

Definition Classes
ManualTester
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def convert[T <: Fix[_, _]](target: T): Double
def createOutputFile(name: String): FileWriter

Definition Classes
ManualTester
var cycles: Int

Definition Classes
AdvTester
val defaultMaxCycles: Int

Definition Classes
AdvTester
var delta: Int

Definition Classes
ManualTester
def doPokeBits(data: Node, x: BigInt, off: Int = 1): Unit

Definition Classes
ManualTester
def do_registered_updates(): Unit

Definition Classes
AdvTester
def do_until(work: ⇒ Unit)(pred: ⇒ Boolean, maxCycles: Int = defaultMaxCycles): Boolean

Definition Classes
AdvTester
def dumpName(data: Node): String

Definition Classes
ManualTester
val dut: Toy

Definition Classes
AdvTester
def emulatorCmd(str: String): String

Sends a command to the emulator and returns the reply.
Sends a command to the emulator and returns the reply. The standard protocol treats a single line as a command, which always returns a single line of reply.

Definition Classes
ManualTester
def ensureDir(dir: String): String

Definition Classes
ManualTester
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def eventually(pred: ⇒ Boolean, maxCycles: Int = defaultMaxCycles): Boolean

Definition Classes
AdvTester
def expect(data: Bits, expected: Float): Boolean

Definition Classes
ManualTester
def expect(data: Bits, expected: Long): Boolean

Definition Classes
ManualTester
def expect(data: Bits, expected: Int): Boolean

Definition Classes
ManualTester
def expect(data: Aggregate, expected: Array[BigInt]): Boolean

Definition Classes
ManualTester
def expect(data: Bits, expected: BigInt): Boolean

Definition Classes
ManualTester
def expect(good: Boolean, msg: String): Boolean

Definition Classes
ManualTester
var failureTime: Int

Definition Classes
ManualTester
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def finish(): Boolean

Definition Classes
ManualTester
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def int(x: Bits): BigInt

Definition Classes
ManualTester
def int(x: Int): BigInt

Definition Classes
ManualTester
def int(x: Boolean): BigInt

Definition Classes
ManualTester
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val isT: Boolean

Definition Classes
ManualTester
var isTrace: Boolean

Definition Classes
ManualTester
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
var ok: Boolean

Definition Classes
ManualTester
var pass: Boolean

Definition Classes
AdvTester
def peek(data: Aggregate): Array[BigInt]

Definition Classes
ManualTester
def peek(data: Bits): BigInt

Definition Classes
ManualTester
def peekAt[T <: Bits](data: Mem[T], off: Int): BigInt

Definition Classes
ManualTester
def peekBits(data: Node, off: Int = 1): BigInt

Definition Classes
ManualTester
def poke(port: Aggregate, target: Array[BigInt]): Unit

Definition Classes
AdvTester → ManualTester
def poke(port: Bits, target: BigInt): Unit

Definition Classes
AdvTester → ManualTester
def pokeAt[T <: Bits](data: Mem[T], x: BigInt, off: Int): Unit

Definition Classes
ManualTester
def pokeBits(data: Node, x: BigInt, off: Int = 1): Unit

Definition Classes
ManualTester
val postprocessors: ArrayBuffer[Processable]

Definition Classes
AdvTester
val preprocessors: ArrayBuffer[Processable]

Definition Classes
AdvTester
var process: Process

Definition Classes
ManualTester
def puts(str: String): Unit

Definition Classes
ManualTester
def reg_poke(port: Aggregate, target: Array[BigInt]): Unit

Definition Classes
AdvTester
def reg_poke(port: Bits, target: BigInt): Unit

Definition Classes
AdvTester
val registered_aggr_updates: HashMap[Aggregate, Array[BigInt]]

Definition Classes
AdvTester
val registered_bits_updates: HashMap[Bits, BigInt]

Definition Classes
AdvTester
def reset(n: Int = 1): Unit

Definition Classes
ManualTester
val rnd: Random

Definition Classes
ManualTester
val sb: StringBuilder

Definition Classes
ManualTester
def setClocks(clocks: HashMap[Clock, Int]): Unit

Definition Classes
ManualTester
def signed_fix(dtype: Bits, rv: BigInt): BigInt

Definition Classes
ManualTester
def signed_peek(target: Bits): Double
def start(): Process

Definition Classes
ManualTester
def step(n: Int): Unit

Definition Classes
ManualTester
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
var t: Int

Definition Classes
ManualTester
def takestep(work: ⇒ Unit = {}): Unit

Definition Classes
AdvTester
def takesteps(n: Int)(work: ⇒ Unit = {}): Unit

Definition Classes
AdvTester
var testErr: InputStream

Definition Classes
ManualTester
var testIn: InputStream

Definition Classes
ManualTester
var testOut: OutputStream

Definition Classes
ManualTester
def toString(): String

Definition Classes
AnyRef → Any
def until(pred: ⇒ Boolean, maxCycles: Int = defaultMaxCycles)(work: ⇒ Unit): Boolean

Definition Classes
AdvTester
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def waitForStreams(): Unit

Waits until the emulator streams are ready.
Waits until the emulator streams are ready. This is a dirty hack related to the way Process works. TODO: FIXME.

Definition Classes
ManualTester
def wire_poke(port: Aggregate, target: Array[BigInt]): Unit

Definition Classes
AdvTester
def wire_poke(port: Bits, target: BigInt): Unit

Definition Classes
AdvTester

Related Doc: package FixedPoint

class ToyTester extends AdvTester[Toy]

Instance Constructors

new ToyTester(dut: Toy)

Type Members

class DecoupledSink[T <: Data, R] extends Processable

class DecoupledSource[T <: Data, R] extends Processable

class ValidSink[T <: Data, R] extends Processable

class ValidSource[T <: Data, R] extends Processable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def Boolean2Int(i: Boolean): Int

object DecoupledSink

object DecoupledSource

object ValidSink

object ValidSource

final def asInstanceOf[T0]: T0

def assert(expr: Boolean, errMsg: String = ""): Boolean

val c: Toy

def clone(): AnyRef

def convert[T <: Fix[_, _]](target: T): Double

def createOutputFile(name: String): FileWriter

var cycles: Int

val defaultMaxCycles: Int

var delta: Int

def doPokeBits(data: Node, x: BigInt, off: Int = 1): Unit

def do_registered_updates(): Unit

def do_until(work: ⇒ Unit)(pred: ⇒ Boolean, maxCycles: Int = defaultMaxCycles): Boolean

def dumpName(data: Node): String

val dut: Toy

def emulatorCmd(str: String): String

def ensureDir(dir: String): String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eventually(pred: ⇒ Boolean, maxCycles: Int = defaultMaxCycles): Boolean

def expect(data: Bits, expected: Float): Boolean

def expect(data: Bits, expected: Long): Boolean

def expect(data: Bits, expected: Int): 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 finish(): Boolean

final def getClass(): Class[_]

def hashCode(): Int

def int(x: Bits): BigInt

def int(x: Int): BigInt

def int(x: Boolean): BigInt

final def isInstanceOf[T0]: Boolean

val isT: Boolean

var isTrace: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

var ok: Boolean

var pass: Boolean

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(port: Aggregate, target: Array[BigInt]): Unit

def poke(port: Bits, target: 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 postprocessors: ArrayBuffer[Processable]

val preprocessors: ArrayBuffer[Processable]

var process: Process

def puts(str: String): Unit

def reg_poke(port: Aggregate, target: Array[BigInt]): Unit

def reg_poke(port: Bits, target: BigInt): Unit

val registered_aggr_updates: HashMap[Aggregate, Array[BigInt]]

val registered_bits_updates: HashMap[Bits, BigInt]

def reset(n: Int = 1): Unit

val rnd: Random

val sb: StringBuilder

def setClocks(clocks: HashMap[Clock, Int]): Unit