# Using theories¶

Theories are a powerful tool for test-driven development, allowing you to test a specific behaviour against all permutations of a set of user-defined parameters known as “data points”.

## Adding theories¶

Adding theories is done by defining data points and a theory function:

```
#include <criterion/theories.h>
TheoryDataPoints(suite_name, test_name) = {
DataPoints(Type0, val0, val1, val2, ..., valN),
DataPoints(Type1, val0, val1, val2, ..., valN),
...
DataPoints(TypeN, val0, val1, val2, ..., valN),
}
Theory((Type0 arg0, Type1 arg1, ..., TypeN argN), suite_name, test_name) {
}
```

`suite_name`

and `test_name`

are the identifiers of the test suite and
the test, respectively. These identifiers must follow the language
identifier format.

`Type0/arg0`

through `TypeN/argN`

are the parameter types and names of theory
theory function and are available in the body of the function.

Datapoints are declared in the same number, type, and order than the parameters
inside the `TheoryDataPoints`

macro, with the `DataPoints`

macro.
Beware! It is undefined behaviour to not have a matching number and type of
theory parameters and datatypes.

Each `DataPoints`

must then specify the values that will be used for the
theory parameter it is linked to (`val0`

through `valN`

).

## Assertions and invariants¶

You can use any `cr_assert`

or `cr_expect`

macro functions inside the body of a
theory function.

Theory invariants are enforced through the `cr_assume(Condition)`

macro function:
if `Condition`

is false, then the current theory iteration aborts without
making the test fail.

On top of those, more `assume`

macro functions are available for common operations:

Macro | Description |
---|---|

`cr_assume_not(Condition)` |
Assumes Condition is false. |

`cr_assume_null(Ptr)` |
Assumes Ptr is NULL. |

`cr_assume_not_null(Ptr)` |
Assumes Ptr is not NULL. |

`cr_assume_eq(Actual, Expected)` |
Assumes Actual == Expected. |

`cr_assume_neq(Actual, Unexpected)` |
Assumes Actual != Expected. |

`cr_assume_lt(Actual, Expected)` |
Assumes Actual < Expected. |

`cr_assume_leq(Actual, Expected)` |
Assumes Actual <= Expected. |

`cr_assume_gt(Actual, Expected)` |
Assumes Actual > Expected. |

`cr_assume_geq(Actual, Expected)` |
Assumes Actual >= Expected. |

`cr_assume_float_eq(Actual, Expected, Epsilon)` |
Assumes Actual == Expected with an error of Epsilon. |

`cr_assume_float_neq(Actual, Unexpected, Epsilon)` |
Assumes Actual != Expected with an error of Epsilon. |

`cr_assume_str_eq(Actual, Expected)` |
Assumes Actual and Expected are the same string. |

`cr_assume_str_neq(Actual, Unexpected)` |
Assumes Actual and Expected are not the same string. |

`cr_assume_str_lt(Actual, Expected)` |
Assumes Actual is less than Expected lexicographically. |

`cr_assume_str_leq(Actual, Expected)` |
Assumes Actual is less or equal to Expected lexicographically. |

`cr_assume_str_gt(Actual, Expected)` |
Assumes Actual is greater than Expected lexicographically. |

`cr_assume_str_geq(Actual, Expected)` |
Assumes Actual is greater or equal to Expected lexicographically. |

`cr_assume_arr_eq(Actual, Expected, Size)` |
Assumes all elements of Actual (from 0 to Size - 1) are equals to those of Expected. |

`cr_assume_arr_neq(Actual, Unexpected, Size)` |
Assumes one or more elements of Actual (from 0 to Size - 1) differs from their counterpart in Expected. |

## Configuring theories¶

Theories can optionally recieve configuration parameters to alter the behaviour
of the underlying test; as such, those parameters are the same ones as the ones
of the `Test`

macro function (c.f. Configuration reference).

## Full sample & purpose of theories¶

We will illustrate how useful theories are with a simple example using Criterion:

### The basics of theories¶

Let us imagine that we want to test if the algebraic properties of integers, and specifically concerning multiplication, are respected by the C language:

```
int my_mul(int lhs, int rhs) {
return lhs * rhs;
}
```

Now, we know that multiplication over integers is commutative, so we first test that:

```
#include <criterion/criterion.h>
Test(algebra, multiplication_is_commutative) {
cr_assert_eq(my_mul(2, 3), my_mul(3, 2));
}
```

However, this test is imperfect, because there is not enough triangulation to
insure that my_mul is indeed commutative. One might be tempted to add more
assertions on other values, but this will never be good enough: commutativity
should work for *any* pair of integers, not just an arbitrary set, but, to be
fair, you cannot just test this behaviour for every integer pair that exists.

Theories purposely bridge these two issues by introducing the concept of “data point” and by refactoring the repeating logic into a dedicated function:

```
#include <criterion/theories.h>
TheoryDataPoints(algebra, multiplication_is_commutative) = {
DataPoints(int, [...]),
DataPoints(int, [...]),
};
Theory((int lhs, int rhs), algebra, multiplication_is_commutative) {
cr_assert_eq(my_mul(lhs, rhs), my_mul(rhs, lhs));
}
```

As you can see, we refactored the assertion into a theory taking two unspecified integers.

We first define some data points in the same order and type the parameters have,
from left to right: the first `DataPoints(int, ...)`

will define the set of values passed
to the `int lhs`

parameter, and the second will define the one passed to `int rhs`

.

Choosing the values of the data point is left to you, but we might as well use
“interesting” values: `0`

, `-1`

, `1`

, `-2`

, `2`

, `INT_MAX`

, and `INT_MIN`

:

```
#include <limits.h>
TheoryDataPoints(algebra, multiplication_is_commutative) = {
DataPoints(int, 0, -1, 1, -2, 2, INT_MAX, INT_MIN),
DataPoints(int, 0, -1, 1, -2, 2, INT_MAX, INT_MIN),
};
```

### Using theory invariants¶

The second thing we can test on multiplication is that it is the inverse function of division. Then, given the division operation:

```
int my_div(int lhs, int rhs) {
return lhs / rhs;
}
```

The associated theory is straight-forward:

```
#include <criterion/theories.h>
TheoryDataPoints(algebra, multiplication_is_inverse_of_division) = {
DataPoints(int, 0, -1, 1, -2, 2, INT_MAX, INT_MIN),
DataPoints(int, 0, -1, 1, -2, 2, INT_MAX, INT_MIN),
};
Theory((int lhs, int rhs), algebra, multiplication_is_inverse_of_division) {
cr_assert_eq(lhs, my_div(my_mul(lhs, rhs), rhs));
}
```

However, we do have a problem because you cannot have the theory function divide
by 0. For this purpose, we can `assume`

than `rhs`

will never be 0:

```
Theory((int lhs, int rhs), algebra, multiplication_is_inverse_of_division) {
cr_assume(rhs != 0);
cr_assert_eq(lhs, my_div(my_mul(lhs, rhs), rhs));
}
```

`cr_assume`

will abort the current theory iteration if the condition is not
fulfiled.

Running the test at that point will raise a big problem with the current
implementation of `my_mul`

and `my_div`

:

```
[----] theories.c:24: Assertion failed: (a) == (bad_div(bad_mul(a, b), b))
[----] Theory algebra::multiplication_is_inverse_of_division failed with the following parameters: (2147483647, 2)
[----] theories.c:24: Assertion failed: (a) == (bad_div(bad_mul(a, b), b))
[----] Theory algebra::multiplication_is_inverse_of_division failed with the following parameters: (-2147483648, 2)
[----] theories.c:24: Unexpected signal caught below this line!
[FAIL] algebra::multiplication_is_inverse_of_division: CRASH!
```

The theory shows that `my_div(my_mul(INT_MAX, 2), 2)`

and `my_div(my_mul(INT_MIN, 2), 2)`

does not respect the properties for multiplication: it happens that the
behaviour of these two functions is undefined because the operation overflows.

Similarly, the test crashes at the end; debugging shows that the source of the crash is the divison of INT_MAX by -1, which is undefined.

Fixing this is as easy as changing the prototypes of `my_mul`

and `my_div`

to operate on `long long`

rather than `int`

.

## What’s the difference between theories and parameterized tests ?¶

While it may at first seem that theories and parameterized tests are the same, just because they happen to take multiple parameters does not mean that they logically behave in the same manner.

Parameterized tests are useful to test a specific logic against a fixed, *finite*
set of examples that you need to work.

Theories are, well, just that: theories. They represent a test against an universal truth, regardless of the input data matching its predicates.

Implementation-wise, Criterion also marks the separation by the way that both are executed:

Each parameterized test iteration is run in its own test; this means that one parameterized test acts as a collection of many tests, and gets reported as such.

On the other hand, a theory act as one single test, since the size and contents of the generated data set is not relevant. It does not make sense to say that an universal truth is “partially true”, so if one of the iteration fails, then the whole test fails.