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 {
  suite("clock") {
    testM("time is non-zero") {
      assertM(nanoTime, isGreaterThan(0))
    }
  }
}
    Definition Classes
    zio
  • package mock

    The mock package contains testable versions of all the standard ZIO environment types through the MockClock, MockConsole, MockSystem, and MockRandom modules.

    The mock package contains testable versions of all the standard ZIO environment types through the MockClock, MockConsole, MockSystem, and MockRandom modules. See the documentation on the individual modules for more detail about using each of them.

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

    import zio.test.mock._

myProgram.provideManaged(mockEnvironmentManaged)

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

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

    import zio.test.mock._

myProgram.provideM(MockConsole.make(MockConsole.DefaultData))

    Finally, you can create a Mock object that implements the mock interface directly using the makeMock method. This can be useful when you want to access some mocking functionality without using the environment type.

    import zio.test.mock._

for {
  mockRandom <- MockRandom.makeMock(MockRandom.DefaultData)
  n          <- mockRandom.nextInt
} yield n

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

    Definition Classes
    test
  • package reflect
    Definition Classes
    test
  • AbstractRunnableSpec
  • Assertion
  • AssertionValue
  • BoolAlgebra
  • CheckVariants
  • DefaultRunnableSpec
  • DefaultTestReporter
  • DefaultTestRunner
  • ExecutionStrategy
  • FailureDetails
  • Gen
  • GenFailureDetails
  • GenZIO
  • RenderedResult
  • RunnableSpec
  • Sample
  • Sized
  • Spec
  • TestAnnotation
  • TestAnnotationMap
  • TestAspect
  • TestExecutor
  • TestFailure
  • TestLogger
  • TestPlatform
  • TestReporter
  • TestRunner
  • TestSuccess
  • TestTimeoutException
  • TimeoutVariants
  • ZSpecSyntax

object Gen extends GenZIO with Serializable

Linear Supertypes
Serializable, Serializable, GenZIO, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Gen
  2. Serializable
  3. Serializable
  4. GenZIO
  5. AnyRef
  6. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

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. final val alphaNumericChar: Gen[Random, Char]

    A generator of alphanumeric characters.

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

  5. final val anyByte: Gen[Random, Byte]

    A generator of bytes.

    A generator of bytes. Shrinks toward '0'.

  6. final val anyChar: Gen[Random, Char]

    A generator of characters.

    A generator of characters. Shrinks toward '0'.

  7. final val anyFloat: Gen[Random, Float]

    A generator of integers.

    A generator of integers. Shrinks toward '0'.

  8. final val anyInt: Gen[Random, Int]

    A generator of integers.

    A generator of integers. Shrinks toward '0'.

  9. final val anyLong: Gen[Random, Long]

    A generator of longs.

    A generator of longs. Shrinks toward '0'.

  10. final val anyShort: Gen[Random, Short]

    A generator of shorts.

    A generator of shorts. Shrinks toward '0'.

  11. final val anyString: Gen[Random with Sized, String]

    A generator of strings.

    A generator of strings. Shrinks towards the empty string.

  12. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  13. final val boolean: Gen[Random, Boolean]

    A generator of booleans.

    A generator of booleans. Shrinks toward 'false'.

  14. final 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").

  15. 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
  16. 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
  17. final 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").

  18. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  19. 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
  20. final def const[A](a: ⇒ A): Gen[Any, A]

    A constant generator of the specified value.

  21. final def constSample[R, A](sample: ⇒ Sample[R, A]): Gen[R, A]

    A constant generator of the specified sample.

  22. final def died[R](gen: Gen[R, Throwable]): Gen[R, ZIO[Any, Nothing, Nothing]]

    A generator of effects that have died with a Throwable.

    A generator of effects that have died with a Throwable.

    Definition Classes
    GenZIO
  23. final 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").

  24. final def either[R <: Random, A, B](left: Gen[R, A], right: Gen[R, B]): Gen[R, Either[A, B]]
  25. final def elements[A](as: A*): Gen[Random, A]
  26. final val empty: Gen[Any, Nothing]
  27. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  28. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  29. final 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.

  30. final def failures[R, E](gen: Gen[R, E]): Gen[R, ZIO[Any, 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
  31. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  32. final def fromEffect[R, A](effect: ZIO[R, Nothing, A]): Gen[R, A]

    Constructs a generator from an effect that constructs a value.

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

    Constructs a generator from an effect that constructs a sample.

  34. final def fromIterable[R, A](as: Iterable[A], shrinker: (A) ⇒ ZStream[R, Nothing, A] = (_: A) => ZStream.empty): Gen[R, A]

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

  35. final def fromRandom[A](f: (Service[Any]) ⇒ 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.

  36. final def fromRandomSample[R <: Random, A](f: (Service[Any]) ⇒ UIO[Sample[R, A]]): Gen[R, A]

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

  37. 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.

  38. 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 constent with equality.

  39. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  40. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  41. final 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").

  42. final def integral[A](min: A, max: A)(implicit I: Integral[A]): Gen[Random, A]

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

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

  43. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  44. final 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.

  45. final def listOf[R <: Random with Sized, A](g: Gen[R, A]): Gen[R, List[A]]
  46. final def listOf1[R <: Random with Sized, A](g: Gen[R, A]): Gen[R, List[A]]
  47. final def listOfN[R <: Random, A](n: Int)(g: Gen[R, A]): Gen[R, List[A]]
  48. final 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.

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

    A constant generator of the empty value.

  51. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  52. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  53. final def oneOf[R <: Random, A](as: Gen[R, A]*): Gen[R, A]
  54. final 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.

  55. 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
  56. final 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 functon's domain, if they have the same hashCode.

  57. final 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 constent with equality.

  58. final val printableChar: Gen[Random, Char]

    A generator of printable characters.

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

  59. final 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").

  60. final def size: Gen[Sized, Int]
  61. final def sized[R <: Sized, A](f: (Int) ⇒ Gen[R, A]): Gen[R, A]

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

  62. final 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.

  63. final def some[R, A](gen: Gen[R, A]): Gen[R, Option[A]]
  64. final def string[R <: Random with Sized](char: Gen[R, Char]): Gen[R, String]
  65. final def string1[R <: Random with Sized](char: Gen[R, Char]): Gen[R, String]
  66. final def stringN[R <: Random](n: Int)(char: Gen[R, Char]): Gen[R, String]
  67. final def successes[R, A](gen: Gen[R, A]): Gen[R, ZIO[Any, Nothing, A]]

    A generator of successful effects.

    A generator of successful effects.

    Definition Classes
    GenZIO
  68. final 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.

  69. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  70. final val throwable: Gen[Random, Throwable]

    A generator of throwables.

  71. def toString(): String
    Definition Classes
    AnyRef → Any
  72. final 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.

  73. final val unit: Gen[Any, Unit]

    A constant generator of the unit value.

  74. final def vectorOf[R <: Random with Sized, A](g: Gen[R, A]): Gen[R, Vector[A]]
  75. final def vectorOf1[R <: Random with Sized, A](g: Gen[R, A]): Gen[R, Vector[A]]
  76. final def vectorOfN[R <: Random, A](n: Int)(g: Gen[R, A]): Gen[R, Vector[A]]
  77. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  78. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  79. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  80. final def weighted[R <: Random, A](gs: (Gen[R, A], Double)*): Gen[R, A]

Inherited from Serializable

Inherited from Serializable

Inherited from GenZIO

Inherited from AnyRef

Inherited from Any

Ungrouped