The provided functions parse rules which allow to express some of the most frequent argument checks by typing just a few letters.

```
qassert(x, rules, .var.name = vname(x))
qtest(x, rules)
qexpect(x, rules, info = NULL, label = vname(x))
```

x | [any] |
---|---|

rules | [ |

.var.name | [ |

info | [ |

label | [ |

`qassert`

throws an `R`

exception if object `x`

does
not comply to at least one of the `rules`

and returns the tested object invisibly
otherwise.
`qtest`

behaves the same way but returns `FALSE`

if none of the
`rules`

comply.
`qexpect`

is intended to be inside the unit test framework `testthat`

and
returns an `expectation`

.

The rule is specified in up to three parts.

Class and missingness check. The first letter is an abbreviation for the class. If it is provided uppercase, missing values are prohibited. Supported abbreviations:

`[bB]`

Bool / logical. `[iI]`

Integer. `[xX]`

Integerish (numeric convertible to integer, see `checkIntegerish`

).`[rR]`

Real / double. `[cC]`

Complex. `[nN]`

Numeric (integer or double). `[sS]`

String / character. `[fF]`

Factor `[aA]`

Atomic. `[vV]`

Atomic vector (see `checkAtomicVector`

).`[lL]`

List. Missingness is defined as `NULL`

element.`[mM]`

Matrix. `[dD]`

Data.frame. Missingness is checked recursively on columns. `[pP]`

POSIXct date. `[e]`

Environment. `[0]`

`NULL`

.`[*]`

placeholder to allow any type. `NaN`

and`NA`

. Infinite values are not treated as missing, but can be caught using boundary checks (part 3).Length definition. This can be one of

`[*]`

any length, `[?]`

length of zero or one, `[+]`

length of at least one, or `[0-9]+`

exact length specified as integer. `=`

/`==`

,`<`

,`<=`

,`>=`

or`>`

is also supported.Range check as two numbers separated by a comma, enclosed by square brackets (endpoint included) or parentheses (endpoint excluded). For example, “[0, 3)” results in

`all(x >= 0 & x < 3)`

. The lower and upper bound may be omitted which is the equivalent of a negative or positive infinite bound, respectively. By definition`[0,]`

contains`Inf`

, while`[0,)`

does not. The same holds for the left (lower) boundary and`-Inf`

. E.g., the rule “N1()” checks for a single finite numeric which is not NA, while “N1[)” allows`-Inf`

.

The functions are inspired by the blog post of Bogumił Kamiński: http://rsnippets.blogspot.de/2013/06/testing-function-agruments-in-gnu-r.html. The implementation is mostly written in C to minimize the overhead.

```
# logical of length 1
qtest(NA, "b1")
#> [1] TRUE
# logical of length 1, NA not allowed
qtest(NA, "B1")
#> [1] FALSE
# logical of length 0 or 1, NA not allowed
qtest(TRUE, "B?")
#> [1] TRUE
# numeric with length > 0
qtest(runif(10), "n+")
#> [1] TRUE
# integer with length > 0, NAs not allowed, all integers >= 0 and < Inf
qtest(1:3, "I+[0,)")
#> [1] TRUE
# either an emtpy list or a character vector with <=5 elements
qtest(1, c("l0", "s<=5"))
#> [1] FALSE
# data frame with at least one column and no missing value in any column
qtest(iris, "D+")
#> [1] TRUE
```