---
title: Std.Test
---

Test framework with assertions, grouping, and focused/skipped test support.

## Types

### TestMode

```saga
type TestMode =
  | Normal
  | OnlyMode
  | SkipMode
```

### TestResult

```saga
record TestResult {
  passed: Int,
  failed: Int,
  skipped: Int
}
```

## Effects

### Test

```saga
effect Test {
  fun assert : (ok: Bool) -> (msg: String) -> Unit
}
```

Effect for assertions inside a single test body.

### Testing

```saga
effect Testing {
  fun register_test : (name: String) -> (mode: TestMode) -> (body: Unit -> Unit needs {Test}) -> Unit
  fun enter_group : (name: String) -> Unit
  fun leave_group : Unit -> Unit
}
```

Effect for defining tests and groups during collection.

## Functions

### test

```saga
fun test : (name: String) -> (body: Unit -> Unit needs {Test}) -> Unit needs {Testing}
```

### only

```saga
fun only : (name: String) -> (body: Unit -> Unit needs {Test}) -> Unit needs {Testing}
```

### skip

```saga
fun skip : (name: String) -> (body: Unit -> Unit needs {Test}) -> Unit needs {Testing}
```

### describe

```saga
fun describe : (name: String) -> (body: Unit -> Unit needs {Testing, ..e}) -> Unit needs {Testing, ..e}
```

### run_modules

```saga
fun run_modules : List (String, Unit -> Unit needs {Testing}) -> Unit
```

### assert_eq

```saga
fun assert_eq : (a: x) -> (b: x) -> Unit needs {Test} where {x: Debug + Eq}
```

### assert_neq

```saga
fun assert_neq : (a: x) -> (b: x) -> Unit needs {Test} where {x: Debug + Eq}
```

### assert_gt

```saga
fun assert_gt : a -> a -> Unit needs {Test} where {a: Debug + Ord}
```

### assert_lt

```saga
fun assert_lt : (a: x) -> (b: x) -> Unit needs {Test} where {x: Debug + Ord}
```

### assert_true

```saga
fun assert_true : Bool -> Unit needs {Test}
```

### assert_false

```saga
fun assert_false : Bool -> Unit needs {Test}
```

### assert_just

```saga
fun assert_just : Maybe a -> Unit needs {Test} where {a: Debug}
```

### assert_nothing

```saga
fun assert_nothing : Maybe a -> Unit needs {Test}
```

### assert_ok

```saga
fun assert_ok : Result a b -> Unit needs {Test} where {b: Debug}
```

### assert_err

```saga
fun assert_err : Result a b -> Unit needs {Test} where {a: Debug}
```

### assert_panics

```saga
fun assert_panics : (f: Unit -> a) -> Unit needs {Test}
```