AssertResult

abstract def canEqual(that: Any): Boolean

abstract def productArity: Int

abstract def productElement(n: Int): Any

final def !=(arg0: Any): Boolean

final def ##(): Int

final def &&[A1 >: A](that: AssertResult[A1]): AssertResult[A1]

Returns a new assert result that is the logical conjunction of this assert result and the specified assert result.

final def ==(arg0: Any): Boolean

final def as[B](b: B): AssertResult[B]

Returns a new assert result, with all values mapped to the specified constant.

final def asInstanceOf[T0]: T0

final def both[A1 >: A](that: AssertResult[A1]): AssertResult[A1]

A named alias for &&.

def clone(): AnyRef

final def collect[B](p: PartialFunction[A, B]): Option[AssertResult[B]]

Returns a new assert result with a filtered, mapped subset of the values in this assert result.

final def either[A1 >: A](that: AssertResult[A1]): AssertResult[A1]

A named alias for ||.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def failures[B](implicit ev: <:<[A, Either[B, _]]): Option[AssertResult[B]]

If this assert value is a success returns None.

def finalize(): Unit

final def fold[B](caseValue: (A) ⇒ B)(caseAnd: (B, B) ⇒ B, caseOr: (B, B) ⇒ B): B

Folds over the assert result bottom up, first converting values to B values, and then combining the B values, using the specified functions.

final def getClass(): Class[_]

final def hashCode(): Int

final def isFailure(implicit ev: <:<[A, Either[_, _]]): Boolean

Determines whether the assert result is a failure, where Left represents failure, Right represents success, and values are combined using logical conjunction and disjunction.

final def isInstanceOf[T0]: Boolean

final def isSuccess(implicit ev: <:<[A, Either[_, _]]): Boolean

Determines whether the assert result is a success, where Left represents failure, Right represents success, and values are combined using logical conjunction and disjunction.

final def map[B](f: (A) ⇒ B): AssertResult[B]

Returns a new assert result, with all values mapped by the specified function.

final def ne(arg0: AnyRef): Boolean

final def not[B, C](implicit ev: <:<[A, Either[B, C]]): AssertResult[Either[C, B]]

Negates this assert result, converting all successes into failures and failures into successes.

final def notify(): Unit

final def notifyAll(): Unit

def productIterator: Iterator[Any]

def productPrefix: String

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def ||[A1 >: A](that: AssertResult[A1]): AssertResult[A1]

Returns a new assert result that is the logical disjunction of this assert result and the specified assert result.