Expectable

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def applyMatcher[S >: T](m: ⇒ Matcher[S]): MatchResult[S]

apply a matcher on the value and return a MatchResult which can later on be transformed to a simple Result

final def asInstanceOf[T0]: T0

def check[S >: T](result: MatchResult[S]): MatchResult[S]

additional checks can be done on the result, such as throwing an exception

def checkResult(result: Result): Result

additional checks can be done on a result, such as throwing an exception

def clone(): AnyRef

def describe(v: Any): String

def description: String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evaluate: Expectable[T]

evaluate the value and return the same expectable

def evaluateOnce: Expectable[T]

evaluate the value once and return an expectable with the same expression, ready to be evaluated again

def flatMap[S](f: (T) ⇒ Expectable[S]): Expectable[S]

apply a function to the value

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[S](other: S): Expectable[S]

change the expectable value

def map[S](f: (T) ⇒ S): Expectable[S]

apply a function to the expectable value

def mapDescription(d: String): Expectable[T]

def mapDescription(d: (String) ⇒ String): Expectable[T]

def mapDescription(d: Option[(String) ⇒ String]): Expectable[T]

apply a function to the description function

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def optionalDescription: Option[(String) ⇒ String]

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

def toString(): String

def updateDescription(d: (String) ⇒ String): Expectable[T]

update the description with another description

lazy val value: T

the value is only evaluated if necessary

lazy val valueDefinition: () ⇒ T

definition of the value, possibly evaluating to different results each time it is invoked

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit