assert {testit}R Documentation

Assertions with an optional message


The function assert() was inspired by stopifnot(). It emits a message in case of errors, which can be a helpful hint for diagnosing the errors (stopifnot() only prints the possibly truncated source code of the expressions).

The infix operator %==% is simply an alias of the identical() function to make it slightly easier and intuitive to write test conditions. x %==% y is the same as identical(x, y).


assert(fact, ...)

x %==% y



a message for the assertions when any of them fails; treated the same way as expressions in ... if it is not a character string, which means you do not have to provide a message to this function


any number of R expressions; see Details

x, y

two R objects to be compared


There are two ways to write R expressions in the ... argument.

The first way is a series of R expressions (each expression is passed as an individual argument) that return vectors of TRUE's (if FALSE is returned anywhere, an error will show up).

The second way is a single R expression wrapped in {} and passed as a single argument. This expression may contain multiple sub-expressions. A sub-expression is treated as a test condition if it is wrapped in () (meaning its value will be checked to see if it is a logical vector containing any FALSE values) , otherwise it is evaluated in the normal way and its value will not be checked. If the value of the last sub-expression is logical, it will also be treated as a test condition.


Invisible NULL if all expressions returned TRUE, otherwise an error is signalled and the user-provided message is emitted.


The internal implementation of assert() is different with the stopifnot() function in R base: (1) the custom message fact is emitted if an error occurs; (2) assert() requires the logical values to be non-empty (logical(0) will trigger an error); (3) if ... contains a compound expression in {} that returns FALSE (e.g., if (TRUE) {1+1; FALSE}), the first and the last but one line of the source code from deparse() are printed in the error message, otherwise the first line is printed; (4) the arguments in ... are evaluated sequentially, and assert() will signal an error upon the first failed assertion, and will ignore the rest of assertions.


## The first way to write assertions --------------------

assert("one equals one", 1 == 1)
assert("seq and : produce equal sequences", seq(1L, 10L) == 1L:10L)
assert("seq and : produce identical sequences", identical(seq(1L, 10L), 1L:10L))

# multiple tests
assert("T is bad for TRUE, and so is F for FALSE", T != TRUE, F != FALSE)

# a mixture of tests
assert("Let's pray all of them will pass", 1 == 1, 1 != 2, letters[4] == "d", 
    rev(rev(letters)) == letters)

# logical(0) cannot pass assert(), although stopifnot() does not care
try(assert("logical(0) cannot pass", 1 == integer(0)))
stopifnot(1 == integer(0))  # it's OK!

# a compound expression
try(assert("this if statement returns TRUE", if (TRUE) {
    x = 1
    x == 2

# no message
assert(!FALSE, TRUE,

## The second way to write assertions -------------------

assert("T is bad for TRUE, and so is F for FALSE", {
    T = FALSE
    F = TRUE
    (T != TRUE)  # note the parentheses
    (F != FALSE)

assert("A Poisson random number is non-negative", {
    x = rpois(1, 10)
    (x >= 0)
    x > -1  # do not need () here because it's the last expression

[Package testit version 0.7 Index]