FiniteGen

abstract def apply(prms: Params): Option[FiniteGenRes[T]]

def !=[U](g: Gen[U]): Prop

final def !=(arg0: Any): Boolean

def !==[U](g: Gen[U]): Prop

final def ##(): Int

def :|(l: Symbol): Gen[FiniteGenRes[T]]

Put a label on the generator to make test reports clearer

def :|(l: String): Gen[FiniteGenRes[T]]

Put a label on the generator to make test reports clearer

def ==[U](g: Gen[U]): Prop

Returns a new property that holds if and only if both this and the given generator generates the same result, or both generators generate no result.

final def ==(arg0: Any): Boolean

def ap[U](g: Gen[(FiniteGenRes[T]) ⇒ U]): Gen[U]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def combine[U, V](g: Gen[U])(f: (Option[FiniteGenRes[T]], Option[U]) ⇒ Option[V]): Gen[V]

def combine3[U, V, W](gu: Gen[U], gv: Gen[V])(f: (Option[FiniteGenRes[T]], Option[U], Option[V]) ⇒ Option[W]): Gen[W]

def combine4[U, V, W, X](gu: Gen[U], gv: Gen[V], gw: Gen[W])(f: (Option[FiniteGenRes[T]], Option[U], Option[V], Option[W]) ⇒ Option[X]): Gen[X]

def combine5[U, V, W, X, Y](gu: Gen[U], gv: Gen[V], gw: Gen[W], gx: Gen[X])(f: (Option[FiniteGenRes[T]], Option[U], Option[V], Option[W], Option[X]) ⇒ Option[Y]): Gen[Y]

def combine6[U, V, W, X, Y, Z](gu: Gen[U], gv: Gen[V], gw: Gen[W], gx: Gen[X], gy: Gen[Y])(f: (Option[FiniteGenRes[T]], Option[U], Option[V], Option[W], Option[X], Option[Y]) ⇒ Option[Z]): Gen[Z]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(p: (FiniteGenRes[T]) ⇒ Boolean): Gen[FiniteGenRes[T]]

def finalize(): Unit

def flatMap[U](f: (FiniteGenRes[T]) ⇒ Gen[U]): Gen[U]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def label(l: String): Gen[FiniteGenRes[T]]

Put a label on the generator to make test reports clearer

var label: String

def map[U](f: (FiniteGenRes[T]) ⇒ U): Gen[U]

def map2[U, V](g: Gen[U])(f: (FiniteGenRes[T], U) ⇒ V): Gen[V]

def map3[U, V, W](gu: Gen[U], gv: Gen[V])(f: (FiniteGenRes[T], U, V) ⇒ W): Gen[W]

def map4[U, V, W, X](gu: Gen[U], gv: Gen[V], gw: Gen[W])(f: (FiniteGenRes[T], U, V, W) ⇒ X): Gen[X]

def map5[U, V, W, X, Y](gu: Gen[U], gv: Gen[V], gw: Gen[W], gx: Gen[X])(f: (FiniteGenRes[T], U, V, W, X) ⇒ Y): Gen[Y]

def map6[U, V, W, X, Y, Z](gu: Gen[U], gv: Gen[V], gw: Gen[W], gx: Gen[X], gy: Gen[Y])(f: (FiniteGenRes[T], U, V, W, X, Y) ⇒ Z): Gen[Z]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def sample: Option[FiniteGenRes[T]]

Generates a sample value by using default parameters

def suchThat(p: (FiniteGenRes[T]) ⇒ Boolean): Gen[FiniteGenRes[T]]

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

def withFilter(p: (FiniteGenRes[T]) ⇒ Boolean): GenWithFilter[FiniteGenRes[T]]

def |[U >: FiniteGenRes[T]](g: Gen[U]): Gen[U]

def |:(l: Symbol): Gen[FiniteGenRes[T]]

Put a label on the generator to make test reports clearer

def |:(l: String): Gen[FiniteGenRes[T]]

Put a label on the generator to make test reports clearer