TestUtilWithoutUnivEq

class Object
trait Matchable
class Any
trait TestUtil
object TestUtil.type

Value members

Concrete methods

def assertChange[A, B : Eq, R](query: => A, block: => R)(actual: (A, A) => B)(expect: (A, R) => B)(implicit evidence$27: Eq[B], q: Line): R
def assertChange[A, B : Eq, R](desc: => String, query: => A, block: => R)(actual: (A, A) => B)(expect: (A, R) => B)(implicit evidence$28: Eq[B], q: Line): R
def assertChangeO[A, B : Eq, R](desc: => Option[String], query: => A, block: => R)(actual: (A, A) => B)(expect: (A, R) => B)(implicit evidence$29: Eq[B], q: Line): R
def assertContains(actual: String, substr: String)(implicit q: Line): Unit
def assertContainsAll(actual: String, substrs: String*)(implicit q: Line): Unit
def assertContainsAllCI(actual: String, substrs: String*)(implicit q: Line): Unit
def assertContainsAny(actual: String, substrs: String*)(implicit q: Line): Unit
def assertContainsAnyCI(actual: String, substrs: String*)(implicit q: Line): Unit
def assertContainsCI(actual: String, substr: String)(implicit q: Line): Unit
def assertDifference[N : Eq, A](query: => N)(expect: N)(block: => A)(implicit evidence$33: Numeric[N], evidence$34: Eq[N], q: Line): A
def assertDifference[N : Eq, A](desc: => String, query: => N)(expect: N)(block: => A)(implicit evidence$35: Numeric[N], evidence$36: Eq[N], q: Line): A
def assertDifferenceO[N : Eq, A](desc: => Option[String], query: => N)(expect: N)(block: => A)(implicit evidence$37: Numeric[N], evidence$38: Eq[N], q: Line): A
def assertEq[A : Eq](actual: A, expect: A)(implicit evidence$1: Eq[A], q: Line): Unit
def assertEq[A : Eq](name: => String, actual: A, expect: A)(implicit evidence$2: Eq[A], q: Line): Unit
def assertEqO[A : Eq](name: => Option[String], actual: A, expect: A)(implicit evidence$3: Eq[A], q: Line): Unit
def assertEqWithTolerance(actual: Double, expect: Double)(implicit l: Line): Unit
def assertEqWithTolerance(name: => String, actual: Double, expect: Double)(implicit l: Line): Unit
def assertEqWithTolerance(actual: Double, expect: Double, tolerance: Double)(implicit l: Line): Unit
def assertEqWithTolerance(name: => String, actual: Double, expect: Double, tolerance: Double)(implicit l: Line): Unit
def assertMap[K : UnivEq, V : Eq](actual: Map[K, V], expect: Map[K, V])(implicit evidence$7: UnivEq[K], evidence$8: Eq[V], q: Line): Unit
def assertMap[K : UnivEq, V : Eq](name: => String, actual: Map[K, V], expect: Map[K, V])(implicit evidence$9: UnivEq[K], evidence$10: Eq[V], q: Line): Unit
def assertMapO[K : UnivEq, V : Eq](name: => Option[String], actual: Map[K, V], expect: Map[K, V])(implicit evidence$11: UnivEq[K], evidence$12: Eq[V], q: Line): Unit
def assertMultiline(actual: String, expect: String)(implicit q: Line): Unit
def assertMultiline(name: => String, actual: String, expect: String)(implicit q: Line): Unit
def assertNoChange[B : Eq, A](query: => B)(block: => A)(implicit evidence$30: Eq[B], q: Line): A
def assertNoChange[B : Eq, A](desc: => String, query: => B)(block: => A)(implicit evidence$31: Eq[B], q: Line): A
def assertNoChangeO[B : Eq, A](desc: => Option[String], query: => B)(block: => A)(implicit evidence$32: Eq[B], q: Line): A
def assertNotContains(actual: String, substr: String)(implicit q: Line): Unit
def assertNotContainsAll(actual: String, substrs: String*)(implicit q: Line): Unit
def assertNotContainsAllCI(actual: String, substrs: String*)(implicit q: Line): Unit
def assertNotContainsAny(actual: String, substrs: String*)(implicit q: Line): Unit
def assertNotContainsAnyCI(actual: String, substrs: String*)(implicit q: Line): Unit
def assertNotContainsCI(actual: String, substr: String)(implicit q: Line): Unit
def assertNotEq[A : Eq](actual: A, expect: A)(implicit evidence$4: Eq[A], q: Line): Unit
def assertNotEq[A : Eq](name: => String, actual: A, expect: A)(implicit evidence$5: Eq[A], q: Line): Unit
def assertSeq[A : Eq](actual: Iterable[A])(expect: A*)(implicit evidence$13: Eq[A], q: Line): Unit
def assertSeq[A : Eq](actual: Iterable[A], expect: Iterable[A])(implicit evidence$14: Eq[A], q: Line): Unit
def assertSeq[A : Eq](name: => String, actual: Iterable[A])(expect: A*)(implicit evidence$15: Eq[A], q: Line): Unit
def assertSeq[A : Eq](name: => String, actual: Iterable[A], expect: Iterable[A])(implicit evidence$16: Eq[A], q: Line): Unit
def assertSeqIgnoreOrder[A : Eq](actual: IterableOnce[A])(expect: A*)(implicit evidence$18: Eq[A], q: Line): Unit
def assertSeqIgnoreOrder[A : Eq](actual: IterableOnce[A], expect: IterableOnce[A])(implicit evidence$19: Eq[A], q: Line): Unit
def assertSeqIgnoreOrder[A : Eq](name: => String, actual: IterableOnce[A])(expect: A*)(implicit evidence$20: Eq[A], q: Line): Unit
def assertSeqIgnoreOrder[A : Eq](name: => String, actual: IterableOnce[A], expect: IterableOnce[A])(implicit evidence$21: Eq[A], q: Line): Unit
def assertSeqIgnoreOrderO[A](name: => Option[String], actual: IterableOnce[A], expect: IterableOnce[A])(implicit q: Line, A: Eq[A]): Unit
def assertSeqO[A : Eq](name: => Option[String], actual: Iterable[A], expect: Iterable[A])(implicit evidence$17: Eq[A], q: Line): Unit
def assertSet[A : UnivEq](actual: Set[A])(expect: A*)(implicit evidence$22: UnivEq[A], q: Line): Unit
def assertSet[A : UnivEq](actual: Set[A], expect: Set[A])(implicit evidence$23: UnivEq[A], q: Line): Unit
def assertSet[A : UnivEq](name: => String, actual: Set[A])(expect: A*)(implicit evidence$24: UnivEq[A], q: Line): Unit
def assertSet[A : UnivEq](name: => String, actual: Set[A], expect: Set[A])(implicit evidence$25: UnivEq[A], q: Line): Unit
def assertSetO[A : UnivEq](name: => Option[String], actual: Set[A], expect: Set[A])(implicit evidence$26: UnivEq[A], q: Line): Unit
def fail(msg: String, clearStackTrace: Boolean, addSrcHint: Boolean)(implicit q: Line): Nothing
def failMethod(method: String)(implicit q: Line): Nothing
def failMethod(method: String, desc: String)(implicit q: Line): Nothing
def failMethod(method: String, desc: Option[String])(implicit q: Line): Nothing
def onError[A](body: => A)(onError: Throwable => Any): A
def onFail[A](body: => A)(onFail: => Any): A
def withAtomicOutput[A](a: => A): A

Inherited methods

inline def assertTastyEq[A](inline actual: A, inline expect: A, inline show: Boolean): Unit
@nowarn("cat=unused")
def assertTypeOf[A](a: => A): TypeTestingUtilDsl[A]
Inherited from:
TypeTestingUtil
def assertTypeOfImplicit[A](implicit a: A): TypeTestingUtilDsl[a.type]
Inherited from:
TypeTestingUtil

Implicits

Inherited implicits

implicit def toTestUtilEitherExt[A, B](x: Either[A, B])(implicit l: Line): EitherExt[A, B]
Inherited from:
TestUtilImplicits

Exports

Inherited defined exports

transparent inline def printCode[A](inline body: A): A
Exported from InlineUtils
transparent inline def printTasty[A](inline body: A): A
Exported from InlineUtils