Prop

Type Members

case class Arg[+T](label: String, arg: T, shrinks: Int, origArg: T, prettyArg: Pretty, prettyOrigArg: Pretty) extends Product with Serializable

A property argument
sealed case class Exception(e: Throwable) extends Status with Product with Serializable

Evaluating the property raised an exception
class ExtendedAny[T] extends AnyRef

A collection of property operators on Any values.
A collection of property operators on Any values. Import Prop.AnyOperators to make the operators available.
class ExtendedBoolean extends AnyRef

A collection of property operators on Boolean values.
A collection of property operators on Boolean values. Import Prop.BooleanOperators to make the operators available.
case class Result(status: Status, args: List[Arg[Any]] = Nil, collected: Set[Any] = Set.empty, labels: Set[String] = Set.empty) extends Product with Serializable

The result of evaluating a property
sealed trait Status extends AnyRef

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
def =?[T](x: T, y: T)(implicit pp: (T) ⇒ Pretty): Prop

Create a property that compares to values.
Create a property that compares to values. If the values aren't equal, the property will fail and report that second value doesn't match the expected (first) value.
def ?=[T](x: T, y: T)(implicit pp: (T) ⇒ Pretty): Prop

Create a property that compares to values.
Create a property that compares to values. If the values aren't equal, the property will fail and report that first value doesn't match the expected (second) value.
implicit def AnyOperators[T](x: ⇒ T)(implicit arg0: (T) ⇒ Pretty): ExtendedAny[T]

Implicit method that makes a number of property operators on values of type Any available in the current scope.
Implicit method that makes a number of property operators on values of type Any available in the current scope. See Prop.ExtendedAny for documentation on the operators.
implicit def BooleanOperators(b: ⇒ Boolean): ExtendedBoolean

Implicit method that makes a number of property operators on boolean values available in the current scope.
Implicit method that makes a number of property operators on boolean values available in the current scope. See Prop.ExtendedBoolean for documentation on the operators.
object False extends Status with Product with Serializable

The property was false
object Proof extends Status with Product with Serializable

The property was proved
object True extends Status with Product with Serializable

The property was true
object Undecided extends Status with Product with Serializable

The property could not be falsified or proved
def all(ps: Prop*): Prop

Combines properties into one, which is true if and only if all the properties are true
def apply(b: Boolean): Prop

Create a property from a boolean value
def apply(r: Result): Prop

Create a property that returns the given result
def apply(f: (Parameters) ⇒ Result): Prop

Create a new property from the given function.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def atLeastOne(ps: Prop*): Prop

Combines properties into one, which is true if at least one of the properties is true
def classify(c: ⇒ Boolean, ifTrue: Any, ifFalse: Any)(prop: Prop): Prop

Collect data for presentation in test report
def classify(c: ⇒ Boolean, ifTrue: Any)(prop: Prop): Prop

Collect data for presentation in test report
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[T](t: T)(prop: Prop): Prop

Collect data for presentation in test report
def collect[T, P](f: (T) ⇒ P)(implicit arg0: (P) ⇒ Prop): (T) ⇒ Prop

Collect data for presentation in test report
def delay(p: ⇒ Prop): Prop

Wraps a property to delay its evaluation.
Wraps a property to delay its evaluation. The given parameter is evaluated each time the wrapper property is evaluated.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exception(e: Throwable): Prop

A property that denotes an exception
lazy val exception: Prop

A property that denotes an exception
def exists[A, P](g: Gen[A])(f: (A) ⇒ P)(implicit pv: (P) ⇒ Prop, pp: (A) ⇒ Pretty): Prop

Existential quantifier for an explicit generator.
def exists[A, P](f: (A) ⇒ P)(implicit pv: (P) ⇒ Prop, pp: (A) ⇒ Pretty, aa: Arbitrary[A]): Prop

Existential quantifier for an explicit generator.
lazy val falsified: Prop

A property that always is false
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def forAll[A1, A2, A3, A4, A5, A6, A7, A8, P](f: (A1, A2, A3, A4, A5, A6, A7, A8) ⇒ P)(implicit p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], s3: Shrink[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], s4: Shrink[A4], pp4: (A4) ⇒ Pretty, a5: Arbitrary[A5], s5: Shrink[A5], pp5: (A5) ⇒ Pretty, a6: Arbitrary[A6], s6: Shrink[A6], pp6: (A6) ⇒ Pretty, a7: Arbitrary[A7], s7: Shrink[A7], pp7: (A7) ⇒ Pretty, a8: Arbitrary[A8], s8: Shrink[A8], pp8: (A8) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAll[A1, A2, A3, A4, A5, A6, A7, P](f: (A1, A2, A3, A4, A5, A6, A7) ⇒ P)(implicit p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], s3: Shrink[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], s4: Shrink[A4], pp4: (A4) ⇒ Pretty, a5: Arbitrary[A5], s5: Shrink[A5], pp5: (A5) ⇒ Pretty, a6: Arbitrary[A6], s6: Shrink[A6], pp6: (A6) ⇒ Pretty, a7: Arbitrary[A7], s7: Shrink[A7], pp7: (A7) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAll[A1, A2, A3, A4, A5, A6, P](f: (A1, A2, A3, A4, A5, A6) ⇒ P)(implicit p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], s3: Shrink[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], s4: Shrink[A4], pp4: (A4) ⇒ Pretty, a5: Arbitrary[A5], s5: Shrink[A5], pp5: (A5) ⇒ Pretty, a6: Arbitrary[A6], s6: Shrink[A6], pp6: (A6) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAll[A1, A2, A3, A4, A5, P](f: (A1, A2, A3, A4, A5) ⇒ P)(implicit p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], s3: Shrink[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], s4: Shrink[A4], pp4: (A4) ⇒ Pretty, a5: Arbitrary[A5], s5: Shrink[A5], pp5: (A5) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAll[A1, A2, A3, A4, P](f: (A1, A2, A3, A4) ⇒ P)(implicit p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], s3: Shrink[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], s4: Shrink[A4], pp4: (A4) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAll[A1, A2, A3, P](f: (A1, A2, A3) ⇒ P)(implicit p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], s3: Shrink[A3], pp3: (A3) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAll[A1, A2, P](f: (A1, A2) ⇒ P)(implicit p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAll[A1, P](f: (A1) ⇒ P)(implicit p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAll[T1, T2, T3, T4, T5, T6, T7, T8, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3], g4: Gen[T4], g5: Gen[T5], g6: Gen[T6], g7: Gen[T7], g8: Gen[T8])(f: (T1, T2, T3, T4, T5, T6, T7, T8) ⇒ P)(implicit p: (P) ⇒ Prop, s1: Shrink[T1], pp1: (T1) ⇒ Pretty, s2: Shrink[T2], pp2: (T2) ⇒ Pretty, s3: Shrink[T3], pp3: (T3) ⇒ Pretty, s4: Shrink[T4], pp4: (T4) ⇒ Pretty, s5: Shrink[T5], pp5: (T5) ⇒ Pretty, s6: Shrink[T6], pp6: (T6) ⇒ Pretty, s7: Shrink[T7], pp7: (T7) ⇒ Pretty, s8: Shrink[T8], pp8: (T8) ⇒ Pretty): Prop

Universal quantifier for eight explicit generators.
Universal quantifier for eight explicit generators. Shrinks failed arguments with the default shrink function for the type
def forAll[T1, T2, T3, T4, T5, T6, T7, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3], g4: Gen[T4], g5: Gen[T5], g6: Gen[T6], g7: Gen[T7])(f: (T1, T2, T3, T4, T5, T6, T7) ⇒ P)(implicit p: (P) ⇒ Prop, s1: Shrink[T1], pp1: (T1) ⇒ Pretty, s2: Shrink[T2], pp2: (T2) ⇒ Pretty, s3: Shrink[T3], pp3: (T3) ⇒ Pretty, s4: Shrink[T4], pp4: (T4) ⇒ Pretty, s5: Shrink[T5], pp5: (T5) ⇒ Pretty, s6: Shrink[T6], pp6: (T6) ⇒ Pretty, s7: Shrink[T7], pp7: (T7) ⇒ Pretty): Prop

Universal quantifier for seven explicit generators.
Universal quantifier for seven explicit generators. Shrinks failed arguments with the default shrink function for the type
def forAll[T1, T2, T3, T4, T5, T6, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3], g4: Gen[T4], g5: Gen[T5], g6: Gen[T6])(f: (T1, T2, T3, T4, T5, T6) ⇒ P)(implicit p: (P) ⇒ Prop, s1: Shrink[T1], pp1: (T1) ⇒ Pretty, s2: Shrink[T2], pp2: (T2) ⇒ Pretty, s3: Shrink[T3], pp3: (T3) ⇒ Pretty, s4: Shrink[T4], pp4: (T4) ⇒ Pretty, s5: Shrink[T5], pp5: (T5) ⇒ Pretty, s6: Shrink[T6], pp6: (T6) ⇒ Pretty): Prop

Universal quantifier for six explicit generators.
Universal quantifier for six explicit generators. Shrinks failed arguments with the default shrink function for the type
def forAll[T1, T2, T3, T4, T5, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3], g4: Gen[T4], g5: Gen[T5])(f: (T1, T2, T3, T4, T5) ⇒ P)(implicit p: (P) ⇒ Prop, s1: Shrink[T1], pp1: (T1) ⇒ Pretty, s2: Shrink[T2], pp2: (T2) ⇒ Pretty, s3: Shrink[T3], pp3: (T3) ⇒ Pretty, s4: Shrink[T4], pp4: (T4) ⇒ Pretty, s5: Shrink[T5], pp5: (T5) ⇒ Pretty): Prop

Universal quantifier for five explicit generators.
Universal quantifier for five explicit generators. Shrinks failed arguments with the default shrink function for the type
def forAll[T1, T2, T3, T4, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3], g4: Gen[T4])(f: (T1, T2, T3, T4) ⇒ P)(implicit p: (P) ⇒ Prop, s1: Shrink[T1], pp1: (T1) ⇒ Pretty, s2: Shrink[T2], pp2: (T2) ⇒ Pretty, s3: Shrink[T3], pp3: (T3) ⇒ Pretty, s4: Shrink[T4], pp4: (T4) ⇒ Pretty): Prop

Universal quantifier for four explicit generators.
Universal quantifier for four explicit generators. Shrinks failed arguments with the default shrink function for the type
def forAll[T1, T2, T3, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3])(f: (T1, T2, T3) ⇒ P)(implicit p: (P) ⇒ Prop, s1: Shrink[T1], pp1: (T1) ⇒ Pretty, s2: Shrink[T2], pp2: (T2) ⇒ Pretty, s3: Shrink[T3], pp3: (T3) ⇒ Pretty): Prop

Universal quantifier for three explicit generators.
Universal quantifier for three explicit generators. Shrinks failed arguments with the default shrink function for the type
def forAll[T1, T2, P](g1: Gen[T1], g2: Gen[T2])(f: (T1, T2) ⇒ P)(implicit p: (P) ⇒ Prop, s1: Shrink[T1], pp1: (T1) ⇒ Pretty, s2: Shrink[T2], pp2: (T2) ⇒ Pretty): Prop

Universal quantifier for two explicit generators.
Universal quantifier for two explicit generators. Shrinks failed arguments with the default shrink function for the type
def forAll[T1, P](g1: Gen[T1])(f: (T1) ⇒ P)(implicit p: (P) ⇒ Prop, s1: Shrink[T1], pp1: (T1) ⇒ Pretty): Prop

Universal quantifier for an explicit generator.
Universal quantifier for an explicit generator. Shrinks failed arguments with the default shrink function for the type
def forAllNoShrink[A1, A2, A3, A4, A5, A6, A7, A8, P](f: (A1, A2, A3, A4, A5, A6, A7, A8) ⇒ P)(implicit pv: (P) ⇒ Prop, a1: Arbitrary[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], pp4: (A4) ⇒ Pretty, a5: Arbitrary[A5], pp5: (A5) ⇒ Pretty, a6: Arbitrary[A6], pp6: (A6) ⇒ Pretty, a7: Arbitrary[A7], pp7: (A7) ⇒ Pretty, a8: Arbitrary[A8], pp8: (A8) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAllNoShrink[A1, A2, A3, A4, A5, A6, A7, P](f: (A1, A2, A3, A4, A5, A6, A7) ⇒ P)(implicit pv: (P) ⇒ Prop, a1: Arbitrary[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], pp4: (A4) ⇒ Pretty, a5: Arbitrary[A5], pp5: (A5) ⇒ Pretty, a6: Arbitrary[A6], pp6: (A6) ⇒ Pretty, a7: Arbitrary[A7], pp7: (A7) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAllNoShrink[A1, A2, A3, A4, A5, A6, P](f: (A1, A2, A3, A4, A5, A6) ⇒ P)(implicit pv: (P) ⇒ Prop, a1: Arbitrary[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], pp4: (A4) ⇒ Pretty, a5: Arbitrary[A5], pp5: (A5) ⇒ Pretty, a6: Arbitrary[A6], pp6: (A6) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAllNoShrink[A1, A2, A3, A4, A5, P](f: (A1, A2, A3, A4, A5) ⇒ P)(implicit pv: (P) ⇒ Prop, a1: Arbitrary[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], pp4: (A4) ⇒ Pretty, a5: Arbitrary[A5], pp5: (A5) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAllNoShrink[A1, A2, A3, A4, P](f: (A1, A2, A3, A4) ⇒ P)(implicit pv: (P) ⇒ Prop, a1: Arbitrary[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], pp4: (A4) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAllNoShrink[A1, A2, A3, P](f: (A1, A2, A3) ⇒ P)(implicit pv: (P) ⇒ Prop, a1: Arbitrary[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], pp3: (A3) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAllNoShrink[A1, A2, P](f: (A1, A2) ⇒ P)(implicit pv: (P) ⇒ Prop, a1: Arbitrary[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], pp2: (A2) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAllNoShrink[A1, P](f: (A1) ⇒ P)(implicit pv: (P) ⇒ Prop, a1: Arbitrary[A1], pp1: (A1) ⇒ Pretty): Prop

Converts a function into a universally quantified property
def forAllNoShrink[T1, T2, T3, T4, T5, T6, T7, T8, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3], g4: Gen[T4], g5: Gen[T5], g6: Gen[T6], g7: Gen[T7], g8: Gen[T8])(f: (T1, T2, T3, T4, T5, T6, T7, T8) ⇒ P)(implicit p: (P) ⇒ Prop, pp1: (T1) ⇒ Pretty, pp2: (T2) ⇒ Pretty, pp3: (T3) ⇒ Pretty, pp4: (T4) ⇒ Pretty, pp5: (T5) ⇒ Pretty, pp6: (T6) ⇒ Pretty, pp7: (T7) ⇒ Pretty, pp8: (T8) ⇒ Pretty): Prop

Universal quantifier for eight explicit generators.
Universal quantifier for eight explicit generators. Does not shrink failed test cases.
def forAllNoShrink[T1, T2, T3, T4, T5, T6, T7, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3], g4: Gen[T4], g5: Gen[T5], g6: Gen[T6], g7: Gen[T7])(f: (T1, T2, T3, T4, T5, T6, T7) ⇒ P)(implicit p: (P) ⇒ Prop, pp1: (T1) ⇒ Pretty, pp2: (T2) ⇒ Pretty, pp3: (T3) ⇒ Pretty, pp4: (T4) ⇒ Pretty, pp5: (T5) ⇒ Pretty, pp6: (T6) ⇒ Pretty, pp7: (T7) ⇒ Pretty): Prop

Universal quantifier for seven explicit generators.
Universal quantifier for seven explicit generators. Does not shrink failed test cases.
def forAllNoShrink[T1, T2, T3, T4, T5, T6, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3], g4: Gen[T4], g5: Gen[T5], g6: Gen[T6])(f: (T1, T2, T3, T4, T5, T6) ⇒ P)(implicit p: (P) ⇒ Prop, pp1: (T1) ⇒ Pretty, pp2: (T2) ⇒ Pretty, pp3: (T3) ⇒ Pretty, pp4: (T4) ⇒ Pretty, pp5: (T5) ⇒ Pretty, pp6: (T6) ⇒ Pretty): Prop

Universal quantifier for six explicit generators.
Universal quantifier for six explicit generators. Does not shrink failed test cases.
def forAllNoShrink[T1, T2, T3, T4, T5, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3], g4: Gen[T4], g5: Gen[T5])(f: (T1, T2, T3, T4, T5) ⇒ P)(implicit p: (P) ⇒ Prop, pp1: (T1) ⇒ Pretty, pp2: (T2) ⇒ Pretty, pp3: (T3) ⇒ Pretty, pp4: (T4) ⇒ Pretty, pp5: (T5) ⇒ Pretty): Prop

Universal quantifier for five explicit generators.
Universal quantifier for five explicit generators. Does not shrink failed test cases.
def forAllNoShrink[T1, T2, T3, T4, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3], g4: Gen[T4])(f: (T1, T2, T3, T4) ⇒ P)(implicit p: (P) ⇒ Prop, pp1: (T1) ⇒ Pretty, pp2: (T2) ⇒ Pretty, pp3: (T3) ⇒ Pretty, pp4: (T4) ⇒ Pretty): Prop

Universal quantifier for four explicit generators.
Universal quantifier for four explicit generators. Does not shrink failed test cases.
def forAllNoShrink[T1, T2, T3, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3])(f: (T1, T2, T3) ⇒ P)(implicit p: (P) ⇒ Prop, pp1: (T1) ⇒ Pretty, pp2: (T2) ⇒ Pretty, pp3: (T3) ⇒ Pretty): Prop

Universal quantifier for three explicit generators.
Universal quantifier for three explicit generators. Does not shrink failed test cases.
def forAllNoShrink[T1, T2, P](g1: Gen[T1], g2: Gen[T2])(f: (T1, T2) ⇒ P)(implicit p: (P) ⇒ Prop, pp1: (T1) ⇒ Pretty, pp2: (T2) ⇒ Pretty): Prop

Universal quantifier for two explicit generators.
Universal quantifier for two explicit generators. Does not shrink failed test cases.
def forAllNoShrink[T1, P](g1: Gen[T1])(f: (T1) ⇒ P)(implicit pv: (P) ⇒ Prop, pp1: (T1) ⇒ Pretty): Prop

Universal quantifier for an explicit generator.
Universal quantifier for an explicit generator. Does not shrink failed test cases.
def forAllShrink[T, P](g: Gen[T], shrink: (T) ⇒ Stream[T])(f: (T) ⇒ P)(implicit pv: (P) ⇒ Prop, pp: (T) ⇒ Pretty): Prop

Universal quantifier for an explicit generator.
Universal quantifier for an explicit generator. Shrinks failed arguments with the given shrink function
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def iff[T](x: T, f: PartialFunction[T, Prop]): Prop

Property holds only if the given partial function is defined at x, and returns a property that holds
def imply[T](x: T, f: PartialFunction[T, Prop]): Prop

Implication with several conditions
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def lzy(p: ⇒ Prop): Prop

Wraps a property lazily.
Wraps a property lazily. The given parameter is only evaluated once, and not until the wrapper property is evaluated.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def noneFailing[T](gs: Seq[Gen[T]]): Prop

A property that holds iff none of the given generators fails generating a value
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
lazy val passed: Prop

A property that always is passed
implicit def propBoolean(b: Boolean): Prop

Implicit conversion of Boolean values to Prop values.
def protect(p: ⇒ Prop): Prop

Wraps and protects a property, delaying its evaluation and turning exceptions into test failures.
lazy val proved: Prop

A property that always is proved
def secure[P](p: ⇒ P)(implicit arg0: (P) ⇒ Prop): Prop

Wraps and protects a property, turning exceptions thrown by the property into test failures.
def sizedProp(f: (Int) ⇒ Prop): Prop

A property that depends on the generator size
def someFailing[T](gs: Seq[Gen[T]]): Prop

A property that holds if at least one of the given generators fails generating a value
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def throws[T <: Throwable](c: Class[T])(x: ⇒ Any): Boolean

Returns true if the given statement throws an exception of the specified type
def toString(): String

Definition Classes
AnyRef → Any
lazy val undecided: Prop

A property that never is proved or falsified
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def within(maximumMs: Long)(wrappedProp: ⇒ Prop): Prop

Ensures that the property expression passed in completes within the given space of time.

Related Docs: trait Prop | package scalacheck

object Prop

Type Members

case class Arg[+T](label: String, arg: T, shrinks: Int, origArg: T, prettyArg: Pretty, prettyOrigArg: Pretty) extends Product with Serializable

sealed case class Exception(e: Throwable) extends Status with Product with Serializable

class ExtendedAny[T] extends AnyRef

class ExtendedBoolean extends AnyRef

case class Result(status: Status, args: List[Arg[Any]] = Nil, collected: Set[Any] = Set.empty, labels: Set[String] = Set.empty) extends Product with Serializable

sealed trait Status extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def =?[T](x: T, y: T)(implicit pp: (T) ⇒ Pretty): Prop

def ?=[T](x: T, y: T)(implicit pp: (T) ⇒ Pretty): Prop

implicit def AnyOperators[T](x: ⇒ T)(implicit arg0: (T) ⇒ Pretty): ExtendedAny[T]

implicit def BooleanOperators(b: ⇒ Boolean): ExtendedBoolean

object False extends Status with Product with Serializable

object Proof extends Status with Product with Serializable

object True extends Status with Product with Serializable

object Undecided extends Status with Product with Serializable

def all(ps: Prop*): Prop

def apply(b: Boolean): Prop

def apply(r: Result): Prop

def apply(f: (Parameters) ⇒ Result): Prop

final def asInstanceOf[T0]: T0

def atLeastOne(ps: Prop*): Prop

def classify(c: ⇒ Boolean, ifTrue: Any, ifFalse: Any)(prop: Prop): Prop

def classify(c: ⇒ Boolean, ifTrue: Any)(prop: Prop): Prop

def clone(): AnyRef

def collect[T](t: T)(prop: Prop): Prop

def collect[T, P](f: (T) ⇒ P)(implicit arg0: (P) ⇒ Prop): (T) ⇒ Prop

def delay(p: ⇒ Prop): Prop

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exception(e: Throwable): Prop

lazy val exception: Prop

def exists[A, P](g: Gen[A])(f: (A) ⇒ P)(implicit pv: (P) ⇒ Prop, pp: (A) ⇒ Pretty): Prop

def exists[A, P](f: (A) ⇒ P)(implicit pv: (P) ⇒ Prop, pp: (A) ⇒ Pretty, aa: Arbitrary[A]): Prop

lazy val falsified: Prop

def finalize(): Unit

def forAll[A1, A2, A3, P](f: (A1, A2, A3) ⇒ P)(implicit p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], s3: Shrink[A3], pp3: (A3) ⇒ Pretty): Prop

def forAll[A1, A2, P](f: (A1, A2) ⇒ P)(implicit p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty): Prop

def forAll[A1, P](f: (A1) ⇒ P)(implicit p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty): Prop

def forAll[T1, T2, T3, T4, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3], g4: Gen[T4])(f: (T1, T2, T3, T4) ⇒ P)(implicit p: (P) ⇒ Prop, s1: Shrink[T1], pp1: (T1) ⇒ Pretty, s2: Shrink[T2], pp2: (T2) ⇒ Pretty, s3: Shrink[T3], pp3: (T3) ⇒ Pretty, s4: Shrink[T4], pp4: (T4) ⇒ Pretty): Prop

def forAll[T1, T2, T3, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3])(f: (T1, T2, T3) ⇒ P)(implicit p: (P) ⇒ Prop, s1: Shrink[T1], pp1: (T1) ⇒ Pretty, s2: Shrink[T2], pp2: (T2) ⇒ Pretty, s3: Shrink[T3], pp3: (T3) ⇒ Pretty): Prop

def forAll[T1, T2, P](g1: Gen[T1], g2: Gen[T2])(f: (T1, T2) ⇒ P)(implicit p: (P) ⇒ Prop, s1: Shrink[T1], pp1: (T1) ⇒ Pretty, s2: Shrink[T2], pp2: (T2) ⇒ Pretty): Prop

def forAll[T1, P](g1: Gen[T1])(f: (T1) ⇒ P)(implicit p: (P) ⇒ Prop, s1: Shrink[T1], pp1: (T1) ⇒ Pretty): Prop

def forAllNoShrink[A1, A2, A3, A4, P](f: (A1, A2, A3, A4) ⇒ P)(implicit pv: (P) ⇒ Prop, a1: Arbitrary[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], pp4: (A4) ⇒ Pretty): Prop

def forAllNoShrink[A1, A2, A3, P](f: (A1, A2, A3) ⇒ P)(implicit pv: (P) ⇒ Prop, a1: Arbitrary[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], pp3: (A3) ⇒ Pretty): Prop

def forAllNoShrink[A1, A2, P](f: (A1, A2) ⇒ P)(implicit pv: (P) ⇒ Prop, a1: Arbitrary[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], pp2: (A2) ⇒ Pretty): Prop

def forAllNoShrink[A1, P](f: (A1) ⇒ P)(implicit pv: (P) ⇒ Prop, a1: Arbitrary[A1], pp1: (A1) ⇒ Pretty): Prop

def forAllNoShrink[T1, T2, T3, T4, T5, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3], g4: Gen[T4], g5: Gen[T5])(f: (T1, T2, T3, T4, T5) ⇒ P)(implicit p: (P) ⇒ Prop, pp1: (T1) ⇒ Pretty, pp2: (T2) ⇒ Pretty, pp3: (T3) ⇒ Pretty, pp4: (T4) ⇒ Pretty, pp5: (T5) ⇒ Pretty): Prop

def forAllNoShrink[T1, T2, T3, T4, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3], g4: Gen[T4])(f: (T1, T2, T3, T4) ⇒ P)(implicit p: (P) ⇒ Prop, pp1: (T1) ⇒ Pretty, pp2: (T2) ⇒ Pretty, pp3: (T3) ⇒ Pretty, pp4: (T4) ⇒ Pretty): Prop

def forAllNoShrink[T1, T2, T3, P](g1: Gen[T1], g2: Gen[T2], g3: Gen[T3])(f: (T1, T2, T3) ⇒ P)(implicit p: (P) ⇒ Prop, pp1: (T1) ⇒ Pretty, pp2: (T2) ⇒ Pretty, pp3: (T3) ⇒ Pretty): Prop

def forAllNoShrink[T1, T2, P](g1: Gen[T1], g2: Gen[T2])(f: (T1, T2) ⇒ P)(implicit p: (P) ⇒ Prop, pp1: (T1) ⇒ Pretty, pp2: (T2) ⇒ Pretty): Prop

def forAllNoShrink[T1, P](g1: Gen[T1])(f: (T1) ⇒ P)(implicit pv: (P) ⇒ Prop, pp1: (T1) ⇒ Pretty): Prop

def forAllShrink[T, P](g: Gen[T], shrink: (T) ⇒ Stream[T])(f: (T) ⇒ P)(implicit pv: (P) ⇒ Prop, pp: (T) ⇒ Pretty): Prop

final def getClass(): Class[_]

def hashCode(): Int

def iff[T](x: T, f: PartialFunction[T, Prop]): Prop

def imply[T](x: T, f: PartialFunction[T, Prop]): Prop

final def isInstanceOf[T0]: Boolean

def lzy(p: ⇒ Prop): Prop

final def ne(arg0: AnyRef): Boolean

def noneFailing[T](gs: Seq[Gen[T]]): Prop

final def notify(): Unit

final def notifyAll(): Unit

lazy val passed: Prop

implicit def propBoolean(b: Boolean): Prop

def protect(p: ⇒ Prop): Prop

lazy val proved: Prop

def secure[P](p: ⇒ P)(implicit arg0: (P) ⇒ Prop): Prop

def sizedProp(f: (Int) ⇒ Prop): Prop

def someFailing[T](gs: Seq[Gen[T]]): Prop

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

def throws[T <: Throwable](c: Class[T])(x: ⇒ Any): Boolean

def toString(): String

lazy val undecided: Prop