abstract class PeekPokeTester[+T <: Module] extends AnyRef
- Annotations
- @deprecated
- Deprecated
(Since version chisel-iotesters 2.5.0) chisel-iotesters is end-of-life. Use chiseltest instead, see https://www.chisel-lang.org/chiseltest/migrating-from-iotesters.
- Source
- PeekPokeTester.scala
- Alphabetic
- By Inheritance
- PeekPokeTester
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
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
- implicit val _base: Int
- implicit val _verbose: Boolean
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- val backend: Backend
*************************
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- val dut: T
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def expect(signal: Bundle, expected: Map[String, BigInt]): Boolean
Return true or false if an aggregate signal (Bundle) matches the expected map of values.
Return true or false if an aggregate signal (Bundle) matches the expected map of values. TODO: deal with Vecs
- signal
the Bundle to "expect"
- expected
a map of signal names ("dotted" Bundle notation) to BigInt values
- returns
true if the specified values match, false otherwise.
- 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
Uses a Double as the expected value
Consider using the more reliable expectFixedPointBig
- signal
signal
- expected
value expected
- msg
message on failure
- epsilon
error bounds on expected value are +/- epsilon
- def expectFixedPointBig(signal: FixedPoint, expected: BigDecimal, msg: => String, epsilon: BigDecimal = 0.01): Boolean
Uses a BigDecimal as the expected value
Uses a BigDecimal as the expected value
- signal
signal
- expected
value expected
- msg
message on failure
- epsilon
error bounds on expected value are +/- epsilon
- def expectInterval(signal: Interval, expected: Double, msg: => String, epsilon: Double = 0.01): Boolean
Uses a Double as the expected value
Uses a Double as the expected value
Consider using the more reliable expectIntervalBig
- signal
signal
- expected
value expected
- msg
message on failure
- epsilon
error bounds on expected value are +/- epsilon
- def expectIntervalBig(signal: Interval, expected: BigDecimal, msg: => String, epsilon: BigDecimal = 0.01): Boolean
Uses a BigDecimal as the expected value
Uses a BigDecimal as the expected value
- signal
signal
- expected
value expected
- msg
message on failure
- epsilon
error bounds on expected value are +/- epsilon
- def fail: Unit
- def finish: Boolean
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def incTime(n: Int): Unit
- Attributes
- protected[iotesters]
- 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
Convert an Int to unsigned (effectively 32-bit) BigInt
- x
number to be converted
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- implicit val logger: TestErrorLog
- implicit def longToInt(x: Long): Int
- def longToUnsignedBigInt(x: Long): BigInt
Convert an Int to unsigned (effectively 64-bit) BigInt
Convert an Int to unsigned (effectively 64-bit) BigInt
- x
long to be converted
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- val optionsManager: TesterOptionsManager
- def peek(signal: Bundle): LinkedHashMap[String, BigInt]
Peek an aggregate (Bundle) signal.
Peek an aggregate (Bundle) signal.
- signal
the signal to peek
- returns
a map of signal names ("dotted" Bundle) to BigInt values.
- 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.
Returns the value signal as a Double. Double may not be big enough to contain the value without precision loss. This situation will Throw ChiselException Consider using the more reliable peekFixedPointBig
- def peekFixedPointBig(signal: FixedPoint): BigDecimal
returns the value of signal as BigDecimal
- def peekInterval(signal: Interval): Double
Returns the value signal as a Double.
Returns the value signal as a Double. Double may not be big enough to contain the value without precision loss. This situation will Throw ChiselException Consider using the more reliable peekIntervalBig
- 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.
Poke a Bundle given a map of elements and values.
- signal
the bundle to be poked
- map
a map from names (using '.' to delimit bundle elements), to BigInt 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
- Definition Classes
- AnyRef
- def t: Long
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
Deprecated Value Members
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated