< Back

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")(
    test("time is non-zero") {
      for {
        time <- Live.live(nanoTime)
      } yield assertTrue(time >= 0)
    }
  )
}
```
Definition Classes
zio
package diff
Definition Classes
test
package internal
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.int)
```
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 poly
Definition Classes
test
package render
Definition Classes
test
AbstractRunnableSpec
Annotations
Assert
Assertion
AssertionData
AssertionM
AssertionMData
AssertionResult
AssertionValue
AssertionVariants
BoolAlgebra
BoolAlgebraM
CheckConstructor
CheckConstructorLowPriority1
CheckConstructorLowPriority2
CheckConstructorLowPriority3
CheckConstructorLowPriority4
CheckConstructorLowPriority5
CheckConstructorLowPriority6
CheckConstructorLowPriority7
CheckVariants
CompileVariants
CustomAssertion
DefaultMutableRunnableSpec
DefaultRunnableSpec
DefaultTestReporter
Eql
ErrorMessage
ExecutedSpec
FailureCase
FailureDetails
FunctionVariants
Gen
GenFailureDetails
GenZIO
Live
MutableRunnableSpec
PrettyPrintVersionSpecific
Restorable
Result
RunnableSpec
Sample
Sized
SmartAssertMacros
SmartAssertionOps
Spec
SpecLayerMacros
SuiteConstructor
SuiteConstructorLowPriority1
SuiteConstructorLowPriority2
SuiteConstructorLowPriority3
SuiteConstructorLowPriority4
Summary
SummaryBuilder
TestAnnotation
TestAnnotationMap
TestAnnotationRenderer
TestArgs
TestArrow
TestAspect
TestClock
TestClockPlatformSpecific
TestConfig
TestConsole
TestConstructor
TestConstructorLowPriority1
TestConstructorLowPriority2
TestConstructorLowPriority3
TestConstructorLowPriority4
TestConstructorLowPriority5
TestConstructorLowPriority6
TestConstructorLowPriority7
TestDuration
TestEnvironment
TestExecutor
TestFailure
TestLens
TestLensAnyOps
TestLensCauseOps
TestLensEitherOps
TestLensExitOps
TestLensOptionOps
TestLogger
TestPlatform
TestRandom
TestReporter
TestResult
TestRunner
TestSuccess
TestSystem
TestTimeoutException
TestVersion
TimeVariants
TimeoutVariants
Trace
ZIOSpec
ZIOSpecAbstract
ZIOSpecDefault
ZTest

AssertionM

Companion class AssertionM

object AssertionM

Linear Supertypes

Ordering

Alphabetic
By Inheritance

Inherited

AssertionM
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

Type Members

sealed abstract class Render extends AnyRef
Render captures both the name of an assertion as well as the parameters to the assertion combinator for pretty-printing.
sealed abstract class RenderParam 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 apply[A](_render: Render, _runM: (=> A) => AssertResultM): AssertionM[A]
final def asInstanceOf[T0]: T0
Definition Classes
Any
def assertionDirect[A](name: String)(params: RenderParam*)(run: (=> A) => AssertResultM): AssertionM[A]
Makes a new AssertionM from a pretty-printing and a function.
def assertionM[R, E, A](name: String)(params: RenderParam*)(run: (=> A) => UIO[Boolean])(implicit trace: ZTraceElement): AssertionM[A]
Makes a new AssertionM from a pretty-printing and a function.
def assertionRecM[R, E, A, B](name: String)(params: RenderParam*)(assertion: AssertionM[B])(get: (=> A) => ZIO[Any, Nothing, Option[B]], orElse: (AssertionMData) => AssertResultM = _.asFailureM(ZTraceElement.empty))(implicit trace: ZTraceElement): AssertionM[A]
def clone(): AnyRef
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @native()
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable])
final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def not[A](assertion: AssertionM[A])(implicit trace: ZTraceElement): AssertionM[A]
Makes a new assertion that negates the specified assertion.
final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
def toString(): String
Definition Classes
AnyRef → Any
final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()
object Render
object RenderParam

Inherited from AnyRef

Inherited from Any

Ungrouped