Tester

Instance Constructors

new Tester(c: T, isTrace: Boolean = true, _base: Int = 16)

c
The module under test
isTrace
print the all I/O operations and tests to stdout, default true
_base
base for prints, default 16 (hex)

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
val CC: String

Attributes
protected
Definition Classes
FileSystemUtilities
val CCFLAGS: String

Attributes
protected
Definition Classes
FileSystemUtilities
val CPPFLAGS: String

Attributes
protected
Definition Classes
FileSystemUtilities
val CXX: String

Attributes
protected
Definition Classes
FileSystemUtilities
val CXXFLAGS: String

Attributes
protected
Definition Classes
FileSystemUtilities
val LDFLAGS: String

Attributes
protected
Definition Classes
FileSystemUtilities
val _inputs: ListSet[Bits]
val _outputs: ListSet[Bits]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def cc(dir: String, name: String, flags: String = "", isCC: Boolean = false): Unit

Definition Classes
FileSystemUtilities
val chiselENV: String

Attributes
protected
Definition Classes
FileSystemUtilities
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val cmd: String
val cmdChannelName: String
implicit def cmdToId(cmd: SIM_CMD.Value): Int
def copyToTarget(filename: String): Unit

Definition Classes
FileSystemUtilities
def createOutputFile(name: String): FileWriter

Definition Classes
FileSystemUtilities
var delta: Int
def dumpName(data: Node): String
def ensureDir(dir: String): String

Ensures a directory *dir* exists on the filesystem.
Ensures a directory *dir* exists on the filesystem.

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

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

Definition Classes
AnyRef → Any
val exitValue: Future[Int]
def expect(data: Bits, expected: Float): Boolean
def expect(data: Bits, expected: Float, msg: ⇒ String): Boolean

A tolerant expect for Float Allows for a single least significant bit error in the floating point representation
def expect(data: Dbl, expected: Double): Boolean
def expect(data: Dbl, expected: Double, msg: ⇒ String): Boolean

Expect the value of 'data' to be 'expected'
Expect the value of 'data' to be 'expected'
returns
the test passed
def expect(data: Flo, expected: Float): Boolean
def expect(data: Flo, expected: Float, msg: ⇒ String): Boolean

Expect the value of 'data' to be 'expected'
Expect the value of 'data' to be 'expected'
returns
the test passed
def expect(data: Bits, expected: Long): Boolean
def expect(data: Bits, expected: Long, msg: ⇒ String): Boolean

Expect the value of 'data' to be 'expected'
Expect the value of 'data' to be 'expected'
returns
the test passed
def expect(data: Bits, expected: Int): Boolean
def expect(data: Bits, expected: Int, msg: ⇒ String): Boolean

Expect the value of 'data' to be 'expected'
Expect the value of 'data' to be 'expected'
returns
the test passed
def expect(data: Aggregate, expected: Array[BigInt]): Boolean

Expect the value of Aggregate data to be have the values as passed in with the array
def expect(data: Bits, expected: BigInt): Boolean
def expect(data: Bits, expected: BigInt, msg: ⇒ String): Boolean

Expect the value of data to have the same bits as a BigInt
def expect(good: Boolean, msg: ⇒ String): Boolean

Expect a value to be true printing a message if it passes or fails
Expect a value to be true printing a message if it passes or fails
good
If the test passed or not
msg
The message to print out
def fail: Unit
var failureTime: Int

Indicate a failure has occurred.
def finalize(): Unit

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

Complete the simulation and inspect all tests
def getChunk(id: Int): Int

Attributes
protected
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getId(path: String): Int

Attributes
protected
def hashCode(): Int

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

Convert Bits to BigInt
def int(x: Long): BigInt

Convert a Long to BigInt
def int(x: Int): BigInt

Convert an Int to BigInt
def int(x: Boolean): BigInt

Convert a Boolean to BigInt
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def link(dir: String, target: String, objects: Seq[String], isCC: Boolean = false, isLib: Boolean = false): Unit

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

Definition Classes
AnyRef
def newTestOutputString: String
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
var ok: Boolean
val outChannelName: String
def peek(data: Dbl): Double

Interpret the data as a double precision float
def peek(data: Flo): Float

Interpret data as a single precision float
def peek(data: Aggregate): Array[BigInt]

Peek at Aggregate data
Peek at Aggregate data
returns
an Array of BigInts representing the data
def peek(data: Bits): BigInt

Peek at the value of some bits
Peek at the value of some bits
returns
a BigInt representation of the bits
def peekAt[T <: Bits](data: Mem[T], off: Int): BigInt

Peek at the value of some memory at an index
Peek at the value of some memory at an index
data
Memory to inspect
off
Offset in memory to look at
def peekNode(node: Node, off: Option[Int] = None): BigInt

Peek at the value of a node
Peek at the value of a node
node
Node to peek at
off
The index or offset to inspect
def peekPath(path: String): BigInt

Peek at the value of a node based on the path
def poke(data: Dbl, x: Double): Unit

Set the value of a hardware double precision floating point representation
def poke(data: Flo, x: Float): Unit

Set the value of a hardware single precision floating point representation
def poke(data: Aggregate, x: Array[BigInt]): Unit

Set the value of Aggregate data
def poke(data: Bits, x: BigInt): Unit

Set the value of some 'data' Node
def poke(data: Bits, x: Long): Unit

Set the value of some 'data' Node
def poke(data: Bits, x: Int): Unit

Set the value of some 'data' Node
def poke(data: Bits, x: Boolean): Unit

Set the value of some 'data' Node
def pokeAt[T <: Bits](data: Mem[T], value: BigInt, off: Int): Unit

set the value of some memory
set the value of some memory
data
The memory to write to
value
The BigInt representing the bits to set
off
The offset representing the index to write to memory
def pokeNode(node: Node, v: BigInt, off: Option[Int] = None): Unit

set the value of a node
set the value of a node
node
The node to set
v
The BigInt representing the bits to set
off
The offset or index
def pokePath(path: String, v: BigInt, force: Boolean = false): Unit

set the value of a node with its path
set the value of a node with its path
path
The unique path of the node to set
v
The BigInt representing the bits to set
Example:
1. poke(path, BigInt(63) << 60, 2)
def printfs: Vector[String]
val process: Process
def reset(n: Int = 1): Unit

Send reset to the hardware
Send reset to the hardware
n
number of cycles to hold reset for, default 1
val rnd: Random
def run(cmd: String): Boolean

Definition Classes
FileSystemUtilities
def setClock(clk: Clock, len: Int): Unit
def setClocks(clocks: Iterable[(Clock, Int)]): Unit
def signed_fix(dtype: Bits, rv: BigInt): BigInt
def step(n: Int): Unit

Step time by the smallest amount to the next rising clock edge
Step time by the smallest amount to the next rising clock edge

Note
this is defined based on the period of the clock See Clock
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
var t: Int
def takeStep: Unit

Attributes
protected
val target: String
val targetSubDir: String
def toString(): String

Definition Classes
AnyRef → Any
def update: Unit

Attributes
protected
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( ... )

Related Doc: package Chisel

class Tester[+T <: Module] extends FileSystemUtilities

Instance Constructors

new Tester(c: T, isTrace: Boolean = true, _base: Int = 16)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val CC: String

val CCFLAGS: String

val CPPFLAGS: String

val CXX: String

val CXXFLAGS: String

val LDFLAGS: String

val _inputs: ListSet[Bits]

val _outputs: ListSet[Bits]

final def asInstanceOf[T0]: T0

def cc(dir: String, name: String, flags: String = "", isCC: Boolean = false): Unit

val chiselENV: String

def clone(): AnyRef

val cmd: String

val cmdChannelName: String

implicit def cmdToId(cmd: SIM_CMD.Value): Int

def copyToTarget(filename: String): Unit

def createOutputFile(name: String): FileWriter

var delta: Int

def dumpName(data: Node): String

def ensureDir(dir: String): String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val exitValue: Future[Int]

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

def expect(data: Bits, expected: Float, msg: ⇒ String): Boolean

def expect(data: Dbl, expected: Double): Boolean

def expect(data: Dbl, expected: Double, msg: ⇒ String): Boolean

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

def expect(data: Flo, expected: Float, msg: ⇒ String): Boolean

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

def expect(data: Bits, expected: Long, msg: ⇒ String): Boolean

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

def expect(data: Bits, expected: Int, msg: ⇒ String): Boolean

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

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

def expect(data: Bits, expected: BigInt, msg: ⇒ String): Boolean

def expect(good: Boolean, msg: ⇒ String): Boolean

def fail: Unit

var failureTime: Int

def finalize(): Unit

def finish: Unit

def getChunk(id: Int): Int

final def getClass(): Class[_]

def getId(path: String): Int

def hashCode(): Int

val inChannelName: String

def int(x: Bits): BigInt

def int(x: Long): BigInt

def int(x: Int): BigInt

def int(x: Boolean): BigInt

final def isInstanceOf[T0]: Boolean

def link(dir: String, target: String, objects: Seq[String], isCC: Boolean = false, isLib: Boolean = false): Unit

final def ne(arg0: AnyRef): Boolean

def newTestOutputString: String

final def notify(): Unit

final def notifyAll(): Unit

var ok: Boolean

val outChannelName: String

def peek(data: Dbl): Double

def peek(data: Flo): Float

def peek(data: Aggregate): Array[BigInt]

def peek(data: Bits): BigInt

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

def peekNode(node: Node, off: Option[Int] = None): BigInt

def peekPath(path: String): BigInt

def poke(data: Dbl, x: Double): Unit

def poke(data: Flo, x: Float): Unit

def poke(data: Aggregate, x: Array[BigInt]): Unit

def poke(data: Bits, x: BigInt): Unit

def poke(data: Bits, x: Long): Unit

def poke(data: Bits, x: Int): Unit