PeekPokeTester

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit val _base: Int

implicit val _verbose: Boolean

final def asInstanceOf[T0]: T0

val backend: Backend

*************************

def clone(): AnyRef

val dut: T

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def expect(signal: Bundle, expected: Map[String, BigInt]): Boolean

Return true or false if an aggregate signal (Bundle) matches the expected map of values.

def expect(signal: Aggregate, expected: IndexedSeq[BigInt]): Boolean

def expect[T <: Element](signal: T, expected: Int, msg: ⇒ String)(implicit arg0: Pokeable[T]): Boolean

def expect[T <: Element](signal: T, expected: BigInt, msg: ⇒ String = "")(implicit arg0: Pokeable[T]): Boolean

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

def expectFixedPoint(signal: FixedPoint, expected: Double, msg: ⇒ String, epsilon: Double = 0.01): Boolean

Uses a Double as the expected value

def expectFixedPointBig(signal: FixedPoint, expected: BigDecimal, msg: ⇒ String, epsilon: BigDecimal = 0.01): Boolean

Uses a BigDecimal as the expected value

def expectInterval(signal: Interval, expected: Double, msg: ⇒ String, epsilon: Double = 0.01): Boolean

Uses a Double as the expected value

def expectIntervalBig(signal: Interval, expected: BigDecimal, msg: ⇒ String, epsilon: BigDecimal = 0.01): Boolean

Uses a BigDecimal as the expected value

def fail: Unit

def finish: Boolean

final def getClass(): Class[_]

def hashCode(): Int

def incTime(n: Int): Unit

implicit def int[T <: Element](x: T)(implicit arg0: Pokeable[T]): BigInt

Convert Pokeables to BigInt

implicit def int(x: Boolean): BigInt

Convert a Boolean to BigInt

def intToUnsignedBigInt(x: Int): BigInt

Convert an Int to unsigned (effectively 32-bit) BigInt

final def isInstanceOf[T0]: Boolean

implicit val logger: TestErrorLog

implicit def longToInt(x: Long): Int

def longToUnsignedBigInt(x: Long): BigInt

Convert an Int to unsigned (effectively 64-bit) BigInt

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val optionsManager: TesterOptionsManager

def peek(signal: Bundle): LinkedHashMap[String, BigInt]

Peek an aggregate (Bundle) signal.

def peek(signal: Aggregate): Seq[BigInt]

def peek[T <: Element](signal: T)(implicit arg0: Pokeable[T]): BigInt

def peek(path: String): BigInt

def peekAt[TT <: Element](data: MemBase[TT], off: Int)(implicit arg0: Pokeable[TT]): BigInt

def peekFixedPoint(signal: FixedPoint): Double

Returns the value signal as a Double.

def peekFixedPointBig(signal: FixedPoint): BigDecimal

returns the value of signal as BigDecimal

def peekInterval(signal: Interval): Double

Returns the value signal as a Double.

def peekIntervalBig(signal: Interval): BigDecimal

returns the value of signal as BigDecimal

def poke(signal: Aggregate, value: IndexedSeq[BigInt]): Unit

def poke(signal: Bundle, map: Map[String, BigInt]): Unit

Poke a Bundle given a map of elements and values.

def poke[T <: Element](signal: T, value: Long)(implicit arg0: Pokeable[T]): Unit

def poke[T <: Element](signal: T, value: Int)(implicit arg0: Pokeable[T]): Unit

def poke[T <: Element](signal: T, value: BigInt)(implicit arg0: Pokeable[T]): Unit

def poke(path: String, value: Long): Unit

def poke(path: String, value: Int): Unit

def poke(path: String, value: BigInt): Unit

def pokeAt[TT <: Element](data: MemBase[TT], value: BigInt, off: Int)(implicit arg0: Pokeable[TT]): Unit

def pokeFixedPoint(signal: FixedPoint, value: Double): Unit

def pokeFixedPointBig(signal: FixedPoint, value: BigDecimal): Unit

def pokeInterval(signal: Interval, value: Double): Unit

def pokeIntervalBig(signal: Interval, value: BigDecimal): Unit

def println(msg: String = ""): Unit

def reset(n: Int = 1): Unit

val rnd: Random

def step(n: Int): Unit

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

def t: Long

def toString(): String

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit