trait GenTOps extends MonadGenOps[Gen]
- Alphabetic
- By Inheritance
- GenTOps
- MonadGenOps
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
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
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
boolean: GenT[Boolean]
Generates a random boolean.
Generates a random boolean.
_This generator shrinks to 'False'._
- def byte(range: Range[Byte]): GenT[Byte]
- def char(lo: Char, hi: Char): GenT[Char]
-
def
choice[A](x: GenT[A], xs: List[GenT[A]]): GenT[A]
Randomly selects one of the generators in the list.
Randomly selects one of the generators in the list.
This generator shrinks towards the first generator in the list.
-
def
choice1[A](x: GenT[A], xs: GenT[A]*): GenT[A]
Randomly selects one of the generators in the list.
Randomly selects one of the generators in the list.
This generator shrinks towards the first generator in the list.
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native() @HotSpotIntrinsicCandidate()
-
def
constant[A](x: ⇒ A): GenT[A]
Trivial generator that always produces the same element.
-
def
discard[A](implicit G: MonadGen[Gen]): Gen[A]
Discards the whole generator.
Discards the whole generator.
- Definition Classes
- MonadGenOps
-
def
double(range: Range[Double]): GenT[Double]
*******************************************************************
- def double_(range: Range[Double]): GenT[Double]
-
def
element[A](x: A, xs: List[A]): GenT[A]
Randomly selects one of the elements in the list.
Randomly selects one of the elements in the list.
This generator shrinks towards the first element in the list.
-
def
element1[A](x: A, xs: A*): GenT[A]
Randomly selects one of the elements in the list.
Randomly selects one of the elements in the list.
This generator shrinks towards the first element in the list.
-
def
elementUnsafe[A](xs: List[A]): GenT[A]
Randomly selects one of the elements in the list.
Randomly selects one of the elements in the list.
This generator shrinks towards the first element in the list.
WARNING: This may throw an exception if the list is empty, please use one of the other
element
variants if possible -
def
ensure[A](gen: Gen[A], p: (A) ⇒ Boolean)(implicit F: Monad[Gen], G: MonadGen[Gen]): Gen[A]
Discards the generator if the generated value does not satisfy the predicate.
Discards the generator if the generated value does not satisfy the predicate.
- Definition Classes
- MonadGenOps
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
filter[A](gen: Gen[A])(p: (A) ⇒ Boolean)(implicit F: Monad[Gen], G: MonadGen[Gen]): Gen[A]
Generates a value that satisfies a predicate.
Generates a value that satisfies a predicate.
We keep some state to avoid looping forever. If we trigger these limits then the whole generator is discarded.
- Definition Classes
- MonadGenOps
-
def
frequency[A](a: (Int, GenT[A]), l: List[(Int, GenT[A])]): GenT[A]
Uses a weighted distribution to randomly select one of the generators in the list.
Uses a weighted distribution to randomly select one of the generators in the list.
This generator shrinks towards the first generator in the list.
-
def
frequency1[A](a: (Int, GenT[A]), l: (Int, GenT[A])*): GenT[A]
Uses a weighted distribution to randomly select one of the generators in the list.
Uses a weighted distribution to randomly select one of the generators in the list.
This generator shrinks towards the first generator in the list.
-
def
frequencyUnsafe[A](xs: List[(Int, GenT[A])]): GenT[A]
Uses a weighted distribution to randomly select one of the generators in the list.
Uses a weighted distribution to randomly select one of the generators in the list.
This generator shrinks towards the first generator in the list.
WARNING: This may throw an exception if the list is empty, please use one of the other
frequency
variants if possible. -
def
fromSome[A](gen: Gen[Option[A]])(implicit F: Monad[Gen], G: MonadGen[Gen]): Gen[A]
Runs a
Option
generator until it produces aSome
.Runs a
Option
generator until it produces aSome
.This is implemented using
filter
and has the same caveats.- Definition Classes
- MonadGenOps
-
def
generate[A](f: (Size, Seed) ⇒ (Seed, A))(implicit G: MonadGen[Gen]): Gen[A]
Construct a generator that depends on the size parameter.
Construct a generator that depends on the size parameter.
- Definition Classes
- MonadGenOps
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
def
int(range: Range[Int]): GenT[Int]
*******************************************************************
-
def
integral[A](range: Range[A], fromLong: (Long) ⇒ A)(implicit arg0: Integral[A], F: MonadGen[Gen]): Gen[A]
Generates a random integral number in the given
[inclusive,inclusive]
range.Generates a random integral number in the given
[inclusive,inclusive]
range.When the generator tries to shrink, it will shrink towards the Range.origin of the specified Range.
For example, the following generator will produce a number between
1970
and2100
, but will shrink towards2000
:Gen.integral(Range.constantFrom(2000, 1970, 2100))
Some sample outputs from this generator might look like:
=== Outcome === 1973 === Shrinks === 2000 1987 1980 1976 1974 === Outcome === 2061 === Shrinks === 2000 2031 2046 2054 2058 2060
- Definition Classes
- MonadGenOps
-
def
integral_[A](range: Range[A], fromLong: (Long) ⇒ A)(implicit G: MonadGen[Gen], I: Integral[A]): Gen[A]
Generates a random integral number in the
[inclusive,inclusive]
range.Generates a random integral number in the
[inclusive,inclusive]
range.This generator does not shrink.
- Definition Classes
- MonadGenOps
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
list[A](gen: Gen[A], range: Range[Int])(implicit F: Monad[Gen], G: MonadGen[Gen]): Gen[List[A]]
Generates a list using a 'Range' to determine the length.
Generates a list using a 'Range' to determine the length.
- Definition Classes
- MonadGenOps
- def long(range: Range[Long]): GenT[Long]
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def short(range: Range[Short]): GenT[Short]
-
def
sized[A](f: (Size) ⇒ Gen[A])(implicit F: Monad[Gen], G: MonadGen[Gen]): Gen[A]
Construct a generator that depends on the size parameter.
Construct a generator that depends on the size parameter.
- Definition Classes
- MonadGenOps
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
Deprecated Value Members
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] ) @Deprecated
- Deprecated