Packages

  • package root
    Definition Classes
    root
  • package zio
    Definition Classes
    root
  • package test

    _ZIO Test_ is a featherweight testing library for effectful programs.

    _ZIO Test_ is a featherweight testing library for effectful programs.

    The library imagines every spec as an ordinary immutable value, providing tremendous potential for composition. Thanks to tight integration with ZIO, specs can use resources (including those requiring disposal), have well- defined linear and parallel semantics, and can benefit from a host of ZIO combinators.

    import zio.test._
import zio.clock.nanoTime
import Assertion.isGreaterThan

object MyTest extends DefaultRunnableSpec {
  def spec = suite("clock")(
    testM("time is non-zero") {
      assertM(nanoTime)(isGreaterThan(0))
    }
  )
}
    Definition Classes
    zio
  • package environment

    The environment package contains testable versions of all the standard ZIO environment types through the TestClock, TestConsole, TestSystem, and TestRandom modules.

    The environment package contains testable versions of all the standard ZIO environment types through the TestClock, TestConsole, TestSystem, and TestRandom modules. See the documentation on the individual modules for more detail about using each of them.

    If you are using ZIO Test and extending RunnableSpec a TestEnvironment containing all of them will be automatically provided to each of your tests. Otherwise, the easiest way to use the test implementations in ZIO Test is by providing the TestEnvironment to your program.

    import zio.test.environment._

myProgram.provideLayer(testEnvironment)

    Then all environmental effects, such as printing to the console or generating random numbers, will be implemented by the TestEnvironment and will be fully testable. When you do need to access the "live" environment, for example to print debugging information to the console, just use the live combinator along with the effect as your normally would.

    If you are only interested in one of the test implementations for your application, you can also access them a la carte through the make method on each module. Each test module requires some data on initialization. Default data is included for each as DefaultData.

    import zio.test.environment._

myProgram.provideM(TestConsole.make(TestConsole.DefaultData))

    Finally, you can create a Test object that implements the test interface directly using the makeTest method. This can be useful when you want to access some testing functionality without using the environment type.

    import zio.test.environment._

for {
  testRandom <- TestRandom.makeTest(TestRandom.DefaultData)
  n          <- testRandom.nextInt
} yield n

    This can also be useful when you are creating a more complex environment to provide the implementation for test services that you mix in.

    Definition Classes
    test
  • package laws

    The laws package provides functionality for describing laws as values.

    The laws package provides functionality for describing laws as values. The fundamental abstraction is a set of ZLaws[Caps, R]. These laws model the laws that instances having a capability of type Caps are expected to satisfy. A capability Caps[_] is an abstraction describing some functionality that is common across different data types and obeys certain laws. For example, we can model the capability of two values of a type being compared for equality as follows:

    trait Equal[-A] {
  def equal(a1: A, a2: A): Boolean
}

    Definitions of equality are expected to obey certain laws:

    1. Reflexivity - a1 === a1 2. Symmetry - a1 === a2 ==> a2 === a1 3. Transitivity - (a1 === a2) && (a2 === a3) ==> (a1 === a3)

    These laws define what the capabilities mean and ensure that it is safe to abstract across different instances with the same capability.

    Using ZIO Test, we can represent these laws as values. To do so, we define each law using one of the ZLaws constructors. For example:

    val transitivityLaw = ZLaws.Laws3[Equal]("transitivityLaw") {
  def apply[A: Equal](a1: A, a2: A, a3: A): TestResult =
    ???
}

    We can then combine laws using the + operator:

    val reflexivityLaw: = ???
val symmetryLaw:    = ???

val equalLaws = reflexivityLaw + symmetryLaw + transitivityLaw

    Laws have a run method that takes a generator of values of type A and checks that those values satisfy the laws. In addition, objects can extend ZLawful to provide an even more convenient syntax for users to check that instances satisfy certain laws.

    object Equal extends Lawful[Equal]

object Hash extends Lawful[Hash]

object Ord extends Lawful[Ord]

checkAllLaws(Equal + Hash + Ord)(Gen.anyInt)

    Note that capabilities compose seamlessly because of contravariance. We can combine laws describing different capabilities to construct a set of laws requiring that instances having all of the capabilities satisfy each of the laws.

    Definition Classes
    test
  • package mock
    Definition Classes
    test
  • package poly
    Definition Classes
    test
  • package reflect
    Definition Classes
    test
  • AbstractRunnableSpec
  • Annotations
  • Assertion
  • AssertionData
  • AssertionM
  • AssertionMData
  • AssertionValue
  • AssertionVariants
  • BoolAlgebra
  • BoolAlgebraM
  • CheckVariants
  • CompileVariants
  • DefaultRunnableSpec
  • DefaultTestReporter
  • Eql
  • ExecutedSpec
  • FailureDetails
  • FailureRenderer
  • FunctionVariants
  • Gen
  • GenFailureDetails
  • GenZIO
  • RenderedResult
  • RunnableSpec
  • Sample
  • Sized
  • Spec
  • Summary
  • SummaryBuilder
  • TestAnnotation
  • TestAnnotationMap
  • TestAnnotationRenderer
  • TestArgs
  • TestAspect
  • TestConfig
  • TestExecutor
  • TestFailure
  • TestLogger
  • TestPlatform
  • TestReporter
  • TestRunner
  • TestSuccess
  • TestTimeoutException
  • TestVersion
  • TimeVariants
  • TimeoutVariants
  • ZTest

object Gen extends GenZIO with FunctionVariants with TimeVariants with Serializable

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Gen
  2. Serializable
  3. TimeVariants
  4. FunctionVariants
  5. GenZIO
  6. AnyRef
  7. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. val alphaNumericChar: Gen[Random, Char]

    A generator of alphanumeric characters.

    A generator of alphanumeric characters. Shrinks toward '0'.

  5. val alphaNumericString: Gen[Random with Sized, String]

    A generator of alphanumeric strings.

    A generator of alphanumeric strings. Shrinks towards the empty string.

  6. def alphaNumericStringBounded(min: Int, max: Int): Gen[Random with Sized, String]

    A generator of alphanumeric strings whose size falls within the specified bounds.

  7. def anyASCIIChar: Gen[Random, Char]

    A generator of US-ASCII characters.

    A generator of US-ASCII characters. Shrinks toward '0'.

  8. def anyASCIIString: Gen[Random with Sized, String]

    A generator US-ASCII strings.

    A generator US-ASCII strings. Shrinks towards the empty string.

  9. val anyByte: Gen[Random, Byte]

    A generator of bytes.

    A generator of bytes. Shrinks toward '0'.

  10. val anyChar: Gen[Random, Char]

    A generator of characters.

    A generator of characters. Shrinks toward '0'.

  11. val anyDouble: Gen[Random, Double]

    A generator of doubles.

    A generator of doubles. Shrinks toward '0'.

  12. final def anyFiniteDuration: Gen[Random, Duration]

    A generator of finite zio.duration.Duration values.

    A generator of finite zio.duration.Duration values. Shrinks toward Duration.Zero.

    Definition Classes
    TimeVariants
  13. val anyFloat: Gen[Random, Float]

    A generator of floats.

    A generator of floats. Shrinks toward '0'.

  14. final def anyInstant: Gen[Random, Instant]

    A generator of java.time.Instant values.

    A generator of java.time.Instant values. Shrinks toward Instant.MIN.

    Definition Classes
    TimeVariants
  15. val anyInt: Gen[Random, Int]

    A generator of integers.

    A generator of integers. Shrinks toward '0'.

  16. final def anyLocalDateTime: Gen[Random, LocalDateTime]

    A generator of java.time.LocalDateTime values.

    A generator of java.time.LocalDateTime values. Shrinks toward LocalDateTime.MIN.

    Definition Classes
    TimeVariants
  17. val anyLong: Gen[Random, Long]

    A generator of longs.

    A generator of longs. Shrinks toward '0'.

  18. final def anyOffsetDateTime: Gen[Random, OffsetDateTime]

    A generator of java.time.OffsetDateTime values.

    A generator of java.time.OffsetDateTime values. Shrinks toward OffsetDateTime.MIN.

    Definition Classes
    TimeVariants
  19. val anyShort: Gen[Random, Short]

    A generator of shorts.

    A generator of shorts. Shrinks toward '0'.

  20. def anyString: Gen[Random with Sized, String]

    A generator of strings.

    A generator of strings. Shrinks towards the empty string.

  21. val anyUUID: Gen[Random, UUID]

    A generator of universally unique identifiers.

    A generator of universally unique identifiers. The returned generator will not have any shrinking.

  22. val anyUnicodeChar: Gen[Random, Char]

    A generator of Unicode characters.

    A generator of Unicode characters. Shrinks toward '0'.

  23. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  24. def bigDecimal(min: BigDecimal, max: BigDecimal): Gen[Random, BigDecimal]

    A generator of big decimals inside the specified range: [start, end].

    A generator of big decimals inside the specified range: [start, end]. The shrinker will shrink toward the lower end of the range ("smallest").

    The values generated will have a precision equal to the precision of the difference between max and min.

  25. def bigInt(min: BigInt, max: BigInt): Gen[Random, BigInt]

    A generator of big integers inside the specified range: [start, end].

    A generator of big integers inside the specified range: [start, end]. The shrinker will shrink toward the lower end of the range ("smallest").

  26. val boolean: Gen[Random, Boolean]

    A generator of booleans.

    A generator of booleans. Shrinks toward 'false'.

  27. def bounded[R <: Random, A](min: Int, max: Int)(f: (Int) => Gen[R, A]): Gen[R, A]

    A generator whose size falls within the specified bounds.

  28. def byte(min: Byte, max: Byte): Gen[Random, Byte]

    A generator of byte values inside the specified range: [start, end].

    A generator of byte values inside the specified range: [start, end]. The shrinker will shrink toward the lower end of the range ("smallest").

  29. final def causes[R <: Random with Sized, E](e: Gen[R, E], t: Gen[R, Throwable]): Gen[R, Cause[E]]

    A generator of Cause values

    A generator of Cause values

    Definition Classes
    GenZIO
  30. final def chained[R <: Random with Sized, Env, E, A](gen: Gen[R, ZIO[Env, E, A]]): Gen[R, ZIO[Env, E, A]]

    A generator of effects that are the result of chaining the specified effect with itself a random number of times.

    A generator of effects that are the result of chaining the specified effect with itself a random number of times.

    Definition Classes
    GenZIO
  31. final def chainedN[R <: Random, Env, E, A](n: Int)(zio: Gen[R, ZIO[Env, E, A]]): Gen[R, ZIO[Env, E, A]]

    A generator of effects that are the result of chaining the specified effect with itself a given number of times.

    A generator of effects that are the result of chaining the specified effect with itself a given number of times.

    Definition Classes
    GenZIO
  32. def char(min: Char, max: Char): Gen[Random, Char]

    A generator of character values inside the specified range: [start, end].

    A generator of character values inside the specified range: [start, end]. The shrinker will shrink toward the lower end of the range ("smallest").

  33. def chunkOf[R <: Random with Sized, A](g: Gen[R, A]): Gen[R, Chunk[A]]

    A sized generator of chunks.

  34. def chunkOf1[R <: Random with Sized, A](g: Gen[R, A]): Gen[R, NonEmptyChunk[A]]

    A sized generator of non-empty chunks.

  35. def chunkOfBounded[R <: Random, A](min: Int, max: Int)(g: Gen[R, A]): Gen[R, Chunk[A]]

    A generator of chunks whose size falls within the specified bounds.

  36. def chunkOfN[R <: Random, A](n: Int)(g: Gen[R, A]): Gen[R, Chunk[A]]

    A generator of chunks of the specified size.

  37. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  38. final def concurrent[R, E, A](zio: ZIO[R, E, A]): Gen[Any, ZIO[R, E, A]]

    A generator of effects that are the result of applying concurrency combinators to the specified effect that are guaranteed not to change its value.

    A generator of effects that are the result of applying concurrency combinators to the specified effect that are guaranteed not to change its value.

    Definition Classes
    GenZIO
  39. def const[A](a: => A): Gen[Any, A]

    A constant generator of the specified value.

  40. def constSample[R, A](sample: => Sample[R, A]): Gen[R, A]

    A constant generator of the specified sample.

  41. def crossAll[R, A](gens: Iterable[Gen[R, A]]): Gen[R, List[A]]

    Composes the specified generators to create a cartesian product of elements with the specified function.

  42. def crossN[R, A, B, C, D, F](gen1: Gen[R, A], gen2: Gen[R, B], gen3: Gen[R, C], gen4: Gen[R, D])(f: (A, B, C, D) => F): Gen[R, F]

    Composes the specified generators to create a cartesian product of elements with the specified function.

  43. def crossN[R, A, B, C, D](gen1: Gen[R, A], gen2: Gen[R, B], gen3: Gen[R, C])(f: (A, B, C) => D): Gen[R, D]

    Composes the specified generators to create a cartesian product of elements with the specified function.

  44. def crossN[R, A, B, C](gen1: Gen[R, A], gen2: Gen[R, B])(f: (A, B) => C): Gen[R, C]

    Composes the specified generators to create a cartesian product of elements with the specified function.

  45. final def died[R](gen: Gen[R, Throwable]): Gen[R, UIO[Nothing]]

    A generator of effects that have died with a Throwable.

    A generator of effects that have died with a Throwable.

    Definition Classes
    GenZIO
  46. def double(min: Double, max: Double): Gen[Random, Double]

    A generator of double values inside the specified range: [start, end].

    A generator of double values inside the specified range: [start, end]. The shrinker will shrink toward the lower end of the range ("smallest").

  47. def either[R <: Random, A, B](left: Gen[R, A], right: Gen[R, B]): Gen[R, Either[A, B]]
  48. def elements[A](as: A*): Gen[Random, A]
  49. val empty: Gen[Any, Nothing]
  50. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  51. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  52. val exponential: Gen[Random, Double]

    A generator of exponentially distributed doubles with mean 1.

    A generator of exponentially distributed doubles with mean 1. The shrinker will shrink toward 0.

  53. final def failures[R, E](gen: Gen[R, E]): Gen[R, IO[E, Nothing]]

    A generator of effects that have failed with an error.

    A generator of effects that have failed with an error.

    Definition Classes
    GenZIO
  54. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  55. final def finiteDuration(min: Duration, max: Duration): Gen[Random, Duration]

    A generator of finite zio.duration.Duration values inside the specified range: [min, max].

    A generator of finite zio.duration.Duration values inside the specified range: [min, max]. Shrinks toward min.

    Definition Classes
    TimeVariants
  56. def fromEffect[R, A](effect: URIO[R, A]): Gen[R, A]

    Constructs a generator from an effect that constructs a value.

  57. def fromEffectSample[R, A](effect: ZIO[R, Nothing, Sample[R, A]]): Gen[R, A]

    Constructs a generator from an effect that constructs a sample.

  58. def fromIterable[R, A](as: Iterable[A], shrinker: (A) => ZStream[R, Nothing, A] = defaultShrinker): Gen[R, A]

    Constructs a deterministic generator that only generates the specified fixed values.

  59. final def fromRandom[A](f: (Service) => UIO[A]): Gen[Random, A]

    Constructs a generator from a function that uses randomness.

    Constructs a generator from a function that uses randomness. The returned generator will not have any shrinking.

  60. final def fromRandomSample[R <: Random, A](f: (Service) => UIO[Sample[R, A]]): Gen[R, A]

    Constructs a generator from a function that uses randomness to produce a sample.

  61. final def function[R, A, B](gen: Gen[R, B]): Gen[R, (A) => B]

    Constructs a generator of functions from A to B given a generator of B values.

    Constructs a generator of functions from A to B given a generator of B values. Two A values will be considered to be equal, and thus will be guaranteed to generate the same B value, if they have the same hashCode.

    Definition Classes
    FunctionVariants
  62. final def function2[R, A, B, C](gen: Gen[R, C]): Gen[R, (A, B) => C]

    A version of function that generates functions that accept two parameters.

    A version of function that generates functions that accept two parameters.

    Definition Classes
    FunctionVariants
  63. final def function3[R, A, B, C, D](gen: Gen[R, D]): Gen[R, (A, B, C) => D]

    A version of function that generates functions that accept three parameters.

    A version of function that generates functions that accept three parameters.

    Definition Classes
    FunctionVariants
  64. final def function4[R, A, B, C, D, E](gen: Gen[R, E]): Gen[R, (A, B, C, D) => E]

    A version of function that generates functions that accept four parameters.

    A version of function that generates functions that accept four parameters.

    Definition Classes
    FunctionVariants
  65. final def functionWith[R, A, B](gen: Gen[R, B])(hash: (A) => Int): Gen[R, (A) => B]

    Constructs a generator of functions from A to B given a generator of B values and a hashing function for A values.

    Constructs a generator of functions from A to B given a generator of B values and a hashing function for A values. Two A values will be considered to be equal, and thus will be guaranteed to generate the same B value, if they have have the same hash. This is useful when A does not implement hashCode in a way that is consistent with equality.

    Definition Classes
    FunctionVariants
  66. final def functionWith2[R, A, B, C](gen: Gen[R, C])(hash: (A, B) => Int): Gen[R, (A, B) => C]

    A version of functionWith that generates functions that accept two parameters.

    A version of functionWith that generates functions that accept two parameters.

    Definition Classes
    FunctionVariants
  67. final def functionWith3[R, A, B, C, D](gen: Gen[R, D])(hash: (A, B, C) => Int): Gen[R, (A, B, C) => D]

    A version of functionWith that generates functions that accept three parameters.

    A version of functionWith that generates functions that accept three parameters.

    Definition Classes
    FunctionVariants
  68. final def functionWith4[R, A, B, C, D, E](gen: Gen[R, E])(hash: (A, B, C, D) => Int): Gen[R, (A, B, C, D) => E]

    A version of functionWith that generates functions that accept four parameters.

    A version of functionWith that generates functions that accept four parameters.

    Definition Classes
    FunctionVariants
  69. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  70. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  71. final def instant(min: Instant, max: Instant): Gen[Random, Instant]

    A generator of java.time.Instant values inside the specified range: [min, max].

    A generator of java.time.Instant values inside the specified range: [min, max]. Shrinks toward min.

    Definition Classes
    TimeVariants
  72. def int(min: Int, max: Int): Gen[Random, Int]

    A generator of integers inside the specified range: [start, end].

    A generator of integers inside the specified range: [start, end]. The shrinker will shrink toward the lower end of the range ("smallest").

  73. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  74. val iso_8859_1: Gen[Random with Sized, String]

    A generator of strings that can be encoded in the ISO-8859-1 character set.

  75. def large[R <: Random with Sized, A](f: (Int) => Gen[R, A], min: Int = 0): Gen[R, A]

    A sized generator that uses a uniform distribution of size values.

    A sized generator that uses a uniform distribution of size values. A large number of larger sizes will be generated.

  76. def listOf[R <: Random with Sized, A](g: Gen[R, A]): Gen[R, List[A]]
  77. def listOf1[R <: Random with Sized, A](g: Gen[R, A]): Gen[R, ::[A]]
  78. def listOfBounded[R <: Random, A](min: Int, max: Int)(g: Gen[R, A]): Gen[R, List[A]]

    A generator of lists whose size falls within the specified bounds.

  79. def listOfN[R <: Random, A](n: Int)(g: Gen[R, A]): Gen[R, List[A]]
  80. final def localDateTime(min: LocalDateTime, max: LocalDateTime): Gen[Random, LocalDateTime]

    A generator of java.time.LocalDateTime values inside the specified range: [min, max].

    A generator of java.time.LocalDateTime values inside the specified range: [min, max]. Shrinks toward min.

    Definition Classes
    TimeVariants
  81. def long(min: Long, max: Long): Gen[Random, Long]

    A generator of long values in the specified range: [start, end].

    A generator of long values in the specified range: [start, end]. The shrinker will shrink toward the lower end of the range ("smallest").

  82. def mapOf[R <: Random with Sized, A, B](key: Gen[R, A], value: Gen[R, B]): Gen[R, Map[A, B]]

    A sized generator of maps.

  83. def mapOf1[R <: Random with Sized, A, B](key: Gen[R, A], value: Gen[R, B]): Gen[R, Map[A, B]]

    A sized generator of non-empty maps.

  84. def mapOfBounded[R <: Random, A, B](min: Int, max: Int)(key: Gen[R, A], value: Gen[R, B]): Gen[R, Map[A, B]]

    A generator of maps whose size falls within the specified bounds.

  85. def mapOfN[R <: Random, A, B](n: Int)(key: Gen[R, A], value: Gen[R, B]): Gen[R, Map[A, B]]

    A generator of maps of the specified size.

  86. def medium[R <: Random with Sized, A](f: (Int) => Gen[R, A], min: Int = 0): Gen[R, A]

    A sized generator that uses an exponential distribution of size values.

    A sized generator that uses an exponential distribution of size values. The majority of sizes will be towards the lower end of the range but some larger sizes will be generated as well.

  87. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  88. val none: Gen[Any, Option[Nothing]]

    A constant generator of the empty value.

  89. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  90. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  91. final def offsetDateTime(min: OffsetDateTime, max: OffsetDateTime): Gen[Random, OffsetDateTime]

    A generator of java.time.OffsetDateTime values inside the specified range: [min, max].

    A generator of java.time.OffsetDateTime values inside the specified range: [min, max]. Shrinks toward min.

    Definition Classes
    TimeVariants
  92. def oneOf[R <: Random, A](as: Gen[R, A]*): Gen[R, A]
  93. def option[R <: Random, A](gen: Gen[R, A]): Gen[R, Option[A]]

    A generator of optional values.

    A generator of optional values. Shrinks toward None.

  94. final def parallel[R, E, A](zio: ZIO[R, E, A]): Gen[Any, ZIO[R, E, A]]

    A generator of effects that are the result of applying parallelism combinators to the specified effect that are guaranteed not to change its value.

    A generator of effects that are the result of applying parallelism combinators to the specified effect that are guaranteed not to change its value.

    Definition Classes
    GenZIO
  95. def partialFunction[R <: Random, A, B](gen: Gen[R, B]): Gen[R, PartialFunction[A, B]]

    Constructs a generator of partial functions from A to B given a generator of B values.

    Constructs a generator of partial functions from A to B given a generator of B values. Two A values will be considered to be equal, and thus will be guaranteed to generate the same B value or both be outside the partial function's domain, if they have the same hashCode.

  96. def partialFunctionWith[R <: Random, A, B](gen: Gen[R, B])(hash: (A) => Int): Gen[R, PartialFunction[A, B]]

    Constructs a generator of partial functions from A to B given a generator of B values and a hashing function for A values.

    Constructs a generator of partial functions from A to B given a generator of B values and a hashing function for A values. Two A values will be considered to be equal, and thus will be guaranteed to generate the same B value or both be outside the partial function's domain, if they have have the same hash. This is useful when A does not implement hashCode in a way that is consistent with equality.

  97. val printableChar: Gen[Random, Char]

    A generator of printable characters.

    A generator of printable characters. Shrinks toward '!'.

  98. def setOf[R <: Random with Sized, A](gen: Gen[R, A]): Gen[R, Set[A]]

    A sized generator of sets.

  99. def setOf1[R <: Random with Sized, A](gen: Gen[R, A]): Gen[R, Set[A]]

    A sized generator of non-empty sets.

  100. def setOfBounded[R <: Random, A](min: Int, max: Int)(g: Gen[R, A]): Gen[R, Set[A]]

    A generator of sets whose size falls within the specified bounds.

  101. def setOfN[R <: Random, A](n: Int)(gen: Gen[R, A]): Gen[R, Set[A]]

    A generator of sets of the specified size.

  102. def short(min: Short, max: Short): Gen[Random, Short]

    A generator of short values inside the specified range: [start, end].

    A generator of short values inside the specified range: [start, end]. The shrinker will shrink toward the lower end of the range ("smallest").

  103. def size: Gen[Sized, Int]
  104. def sized[R <: Sized, A](f: (Int) => Gen[R, A]): Gen[R, A]

    A sized generator, whose size falls within the specified bounds.

  105. def small[R <: Random with Sized, A](f: (Int) => Gen[R, A], min: Int = 0): Gen[R, A]

    A sized generator that uses an exponential distribution of size values.

    A sized generator that uses an exponential distribution of size values. The values generated will be strongly concentrated towards the lower end of the range but a few larger values will still be generated.

  106. def some[R, A](gen: Gen[R, A]): Gen[R, Option[A]]
  107. def string[R <: Random with Sized](char: Gen[R, Char]): Gen[R, String]
  108. def string1[R <: Random with Sized](char: Gen[R, Char]): Gen[R, String]
  109. def stringBounded[R <: Random](min: Int, max: Int)(g: Gen[R, Char]): Gen[R, String]

    A generator of strings whose size falls within the specified bounds.

  110. def stringN[R <: Random](n: Int)(char: Gen[R, Char]): Gen[R, String]
  111. final def successes[R, A](gen: Gen[R, A]): Gen[R, UIO[A]]

    A generator of successful effects.

    A generator of successful effects.

    Definition Classes
    GenZIO
  112. def suspend[R, A](gen: => Gen[R, A]): Gen[R, A]

    Lazily constructs a generator.

    Lazily constructs a generator. This is useful to avoid infinite recursion when creating generators that refer to themselves.

  113. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  114. val throwable: Gen[Random, Throwable]

    A generator of throwables.

  115. def toString(): String
    Definition Classes
    AnyRef → Any
  116. def uniform: Gen[Random, Double]

    A generator of uniformly distributed doubles between [0, 1].

    A generator of uniformly distributed doubles between [0, 1]. The shrinker will shrink toward 0.

  117. val unit: Gen[Any, Unit]

    A constant generator of the unit value.

  118. def vectorOf[R <: Random with Sized, A](g: Gen[R, A]): Gen[R, Vector[A]]
  119. def vectorOf1[R <: Random with Sized, A](g: Gen[R, A]): Gen[R, Vector[A]]
  120. def vectorOfBounded[R <: Random, A](min: Int, max: Int)(g: Gen[R, A]): Gen[R, Vector[A]]

    A generator of vectors whose size falls within the specified bounds.

  121. def vectorOfN[R <: Random, A](n: Int)(g: Gen[R, A]): Gen[R, Vector[A]]
  122. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  123. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  124. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  125. def weighted[R <: Random, A](gs: (Gen[R, A], Double)*): Gen[R, A]

    A generator which chooses one of the given generators according to their weights.

    A generator which chooses one of the given generators according to their weights. For example, the following generator will generate 90% true and 10% false values.

    val trueFalse = Gen.weighted((Gen.const(true), 9), (Gen.const(false), 1))
  126. def zipAll[R, A](gens: Iterable[Gen[R, A]]): Gen[R, List[A]]

    Zips the specified generators together pairwise.

    Zips the specified generators together pairwise. The new generator will generate elements as long as any generator is generating elements, running the other generators multiple times if necessary.

  127. def zipN[R, A, B, C, D, F](gen1: Gen[R, A], gen2: Gen[R, B], gen3: Gen[R, C], gen4: Gen[R, D])(f: (A, B, C, D) => F): Gen[R, F]

    Zips the specified generators together pairwise.

    Zips the specified generators together pairwise. The new generator will generate elements as long as any generator is generating elements, running the other generators multiple times if necessary.

  128. def zipN[R, A, B, C, D](gen1: Gen[R, A], gen2: Gen[R, B], gen3: Gen[R, C])(f: (A, B, C) => D): Gen[R, D]

    Zips the specified generators together pairwise.

    Zips the specified generators together pairwise. The new generator will generate elements as long as any generator is generating elements, running the other generators multiple times if necessary.

  129. def zipN[R, A, B, C](gen1: Gen[R, A], gen2: Gen[R, B])(f: (A, B) => C): Gen[R, C]

    Zips the specified generators together pairwise.

    Zips the specified generators together pairwise. The new generator will generate elements as long as any generator is generating elements, running the other generators multiple times if necessary.

Inherited from Serializable

Inherited from TimeVariants

Inherited from FunctionVariants

Inherited from GenZIO

Inherited from AnyRef

Inherited from Any

Ungrouped