Prove is a little and experimental lib that provides the macros `prove`

and `batch`

to use in `ExUnit.Case`

.

A `prove`

is just helpful for elementary tests. Prove generates one test with one assert for every `prove`

.

Example:

```
defmodule NumTest do
use ExUnit.Case
import Prove
defmodule Num do
def check(0), do: :zero
def check(x) when is_integer(x) do
case rem(x, 2) do
0 -> :even
1 -> :odd
end
end
def check(_), do: :error
end
describe "check/1" do
prove Num.check(0) == :zero
batch "returns :odd or :even" do
prove Num.check(1) == :odd
prove Num.check(2) == :even
prove "for big num", Num.check(2_000) == :even
end
batch "returns :error" do
prove Num.check("1") == :error
prove Num.check(nil) == :error
end
end
end
```

The example above generates the following tests:

```
$> mix test test/num_test.exs --trace --seed 0
NumTest [test/num_test.exs]
* prove check/1 (1) (0.00ms) [L#20]
* prove check/1 returns :odd or :even (1) (0.00ms) [L#23]
* prove check/1 returns :odd or :even (2) (0.00ms) [L#24]
* prove check/1 returns :odd or :even for big num (1) (0.00ms) [L#25]
* prove check/1 returns :error (1) (0.00ms) [L#29]
* prove check/1 returns :error (2) (0.00ms) [L#30]
Finished in 0.08 seconds (0.00s async, 0.08s sync)
6 proves, 0 failures
Randomized with seed 0
```

The benefit of `prove`

is that tests with multiple asserts can be avoided.

The example above with regular `test`

s:

```
...
describe "check/1" do
test "returns :zero" do
assert Num.check(0) == :zero
end
test "returns :odd or :even" do
assert Num.check(1) == :odd
assert Num.check(2) == :even
assert Num.check(2_000) == :even
end
test "returns :error" do
assert Num.check("1") == :error
assert Num.check(nil) == :error
end
end
...
```

```
$> mix test test/num_test.exs --trace --seed 0
NumTest [test/num_test.exs]
* test check/1 returns :zero (0.00ms) [L#36]
* test check/1 returns :odd or :even (0.00ms) [L#40]
* test check/1 returns :error (0.00ms) [L#46]
Finished in 0.03 seconds (0.00s async, 0.03s sync)
3 tests, 0 failures
Randomized with seed 0
```

You can find another example in datix.

The disadvantage of these macros is that the tests are containing fewer descriptions. For this reason and also if a `prove`

looks too complicated, a regular `test`

is to prefer.