checkmate/0000755000176200001440000000000013006417455012203 5ustar liggesuserscheckmate/inst/0000755000176200001440000000000013006331417013151 5ustar liggesuserscheckmate/inst/doc/0000755000176200001440000000000013006331417013716 5ustar liggesuserscheckmate/inst/doc/checkmate.R0000644000176200001440000001114313006331417015765 0ustar liggesusers## ----include=FALSE------------------------------------------------------- library(checkmate) ## ------------------------------------------------------------------------ fact <- function(n, method = "stirling") { if (length(n) != 1) stop("Argument 'n' must have length 1") if (!is.numeric(n)) stop("Argument 'n' must be numeric") if (is.na(n)) stop("Argument 'n' may not be NA") if (is.double(n)) { if (is.nan(n)) stop("Argument 'n' may not be NaN") if (is.infinite(n)) stop("Argument 'n' must be finite") if (abs(n - round(n, 0)) > sqrt(.Machine$double.eps)) stop("Argument 'n' must be an integerish value") n <- as.integer(n) } if (n < 0) stop("Argument 'n' must be >= 0") if (length(method) != 1) stop("Argument 'method' must have length 1") if (!is.character(method) || !method %in% c("stirling", "factorial")) stop("Argument 'method' must be either 'stirling' or 'factorial'") if (method == "factorial") factorial(n) else sqrt(2 * pi * n) * (n / exp(1))^n } ## ------------------------------------------------------------------------ fact <- function(n, method = "stirling") { assertCount(n) assertChoice(method, c("stirling", "factorial")) if (method == "factorial") factorial(n) else sqrt(2 * pi * n) * (n / exp(1))^n } ## ------------------------------------------------------------------------ f <- function(x) { assert( checkClass(x, "foo"), checkClass(x, "bar") ) } ## ----eval=FALSE---------------------------------------------------------- # # file: tests/test-all.R # library(testthat) # library(checkmate) # for testthat extensions # test_check("mypkg") ## ----eval=FALSE---------------------------------------------------------- # test_that("checkmate is a sweet extension for testthat", { # x = runif(100) # expect_numeric(x, len = 100, any.missing = FALSE, lower = 0, upper = 1) # # or, equivalent, using the lazy style: # qexpect(x, "N100[0,1]") # }) ## ----dev="svg",fig.width=6,fig.height=4---------------------------------- library(ggplot2) library(microbenchmark) x = TRUE r = function(x, na.ok = FALSE) { stopifnot(is.logical(x), length(x) == 1, na.ok || !is.na(x)) } cm = function(x) assertFlag(x) cmq = function(x) qassert(x, "B1") mb = microbenchmark(r(x), cm(x), cmq(x)) print(mb) autoplot(mb) ## ----dev="svg",fig.width=6,fig.height=4---------------------------------- x = runif(1000) r = function(x) stopifnot(is.numeric(x) && length(x) == 1000 && all(!is.na(x) & x >= 0 & x <= 1)) cm = function(x) assertNumeric(x, len = 1000, any.missing = FALSE, lower = 0, upper = 1) cmq = function(x) qassert(x, "N1000[0,1]") mb = microbenchmark(r(x), cm(x), cmq(x)) print(mb) autoplot(mb) ## ----dev="svg",fig.width=6,fig.height=4---------------------------------- x = sample(letters, 10000, replace = TRUE) r = function(x) stopifnot(is.character(x) && !any(is.na(x)) && all(nchar(x) > 0)) cm = function(x) assertCharacter(x, any.missing = FALSE, min.chars = 1) cmq = function(x) qassert(x, "S+[1,]") mb = microbenchmark(r(x), cm(x), cmq(x)) print(mb) autoplot(mb) ## ----dev="svg",fig.width=6,fig.height=4---------------------------------- N = 10000 x = data.frame(a = runif(N), b = sample(letters[1:5], N, replace = TRUE), c = sample(c(FALSE, TRUE), N, replace = TRUE)) r = function(x) is.data.frame(x) && !any(sapply(x, function(x) any(is.na(x)))) cm = function(x) testDataFrame(x, any.missing = FALSE) cmq = function(x) qtest(x, "D") mb = microbenchmark(r(x), cm(x), cmq(x)) print(mb) autoplot(mb) # checkmate tries to stop as early as possible x$a[1] = NA mb = microbenchmark(r(x), cm(x), cmq(x)) print(mb) autoplot(mb) ## ------------------------------------------------------------------------ checkSquareMatrix = function(x, mode = NULL) { # check functions must return TRUE on success # and a custom error message otherwise res = checkMatrix(x, mode = mode) if (!isTRUE(res)) return(res) if (nrow(x) != ncol(x)) return("Must be square") return(TRUE) } # a quick test: X = matrix(1:9, nrow = 3) checkSquareMatrix(X) checkSquareMatrix(X, mode = "character") checkSquareMatrix(X[1:2, ]) ## ------------------------------------------------------------------------ # For assertions: assert_square_matrix = assertSquareMatrix = makeAssertionFunction(checkSquareMatrix) print(assertSquareMatrix) # For tests: test_square_matrix = testSquareMatrix = makeTestFunction(checkSquareMatrix) print(testSquareMatrix) # For expectations: expect_square_matrix = makeExpectationFunction(checkSquareMatrix) print(expect_square_matrix) ## ------------------------------------------------------------------------ sessionInfo() checkmate/inst/doc/checkmate.Rmd0000644000176200001440000002757413006331417016325 0ustar liggesusers--- title: "Checkmate" author: "Michel Lang" date: "`r Sys.Date()`" output: rmarkdown::html_vignette vignette: > %\VignetteIndexEntry{checkmate} %\VignetteEngine{knitr::rmarkdown} %\VignetteEncoding{UTF-8} --- ```{r,include=FALSE} library(checkmate) ``` Ever used an R function that produced a not-very-helpful error message, just to discover after minutes of debugging that you simply passed a wrong argument? Blaming the laziness of the package author for not doing such standard checks (in a dynamically typed language such as R) is at least partially unfair, as R makes theses types of checks cumbersome and annoying. Well, that's how it was in the past. Enter checkmate. Virtually **every standard type of user error** when passing arguments into function can be caught with a simple, readable line which produces an **informative error message** in case. A substantial part of the package was written in C to **minimize any worries about execution time overhead**. ## Intro As a motivational example, consider you have a function to calculate the faculty of a natural number and the user may choose between using either the stirling approximation or R's `factorial` function (which internally uses the gamma function). Thus, you have two arguments, `n` and `method`. Argument `n` must obviously be a positive natural number and `method` must be either `"stirling"` or `"factorial"`. Here is a version of all the hoops you need to jump through to ensure that these simple requirements are met: ```{r} fact <- function(n, method = "stirling") { if (length(n) != 1) stop("Argument 'n' must have length 1") if (!is.numeric(n)) stop("Argument 'n' must be numeric") if (is.na(n)) stop("Argument 'n' may not be NA") if (is.double(n)) { if (is.nan(n)) stop("Argument 'n' may not be NaN") if (is.infinite(n)) stop("Argument 'n' must be finite") if (abs(n - round(n, 0)) > sqrt(.Machine$double.eps)) stop("Argument 'n' must be an integerish value") n <- as.integer(n) } if (n < 0) stop("Argument 'n' must be >= 0") if (length(method) != 1) stop("Argument 'method' must have length 1") if (!is.character(method) || !method %in% c("stirling", "factorial")) stop("Argument 'method' must be either 'stirling' or 'factorial'") if (method == "factorial") factorial(n) else sqrt(2 * pi * n) * (n / exp(1))^n } ``` And for comparison, here is the same function using checkmate: ```{r} fact <- function(n, method = "stirling") { assertCount(n) assertChoice(method, c("stirling", "factorial")) if (method == "factorial") factorial(n) else sqrt(2 * pi * n) * (n / exp(1))^n } ``` ## Function overview The functions can be split into four functional groups, indicated by their prefix. If prefixed with `assert`, an error is thrown if the corresponding check fails. Otherwise, the checked object is returned invisibly. There are many different coding styles out there in the wild, but most R programmers stick to either `camelBack` or `underscore_case`. Therefore, `checkmate` offers all functions in both flavors: `assert_count` is just an alias for `assertCount` but allows you to retain your favorite style. The family of functions prefixed with `test` always return the check result as logical value. Again, you can use `test_count` and `testCount` interchangeably. Functions starting with `check` return the error message as a string (or `TRUE` otherwise) and can be used if you need more control and, e.g., want to grep on the returned error message. `expect` is the last family of functions and is intended to be used with the [testthat package](https://cran.r-project.org/package=testthat). All performed checks are logged into the `testthat` reporter. Because `testthat` uses the `underscore_case`, the extension functions only come in the underscore style. All functions are categorized into objects to check on the [package help page](https://mllg.github.io/checkmate/reference/checkmate-package). ## In case you miss flexibility You can use [assert](https://mllg.github.io/checkmate/reference/assert) to perform multiple checks at once and throw an assertion if all checks fail. Here is an example where we check that x is either of class `foo` or class `bar`: ```{r} f <- function(x) { assert( checkClass(x, "foo"), checkClass(x, "bar") ) } ``` Note that `assert(, combine = "or")` and `assert(, combine = "and")` allow to control the logical combination of the specified checks, and that the former is the default. ## Argument Checks for the Lazy The following functions allow a special syntax to define argument checks using a special format specification. E.g., `qassert(x, "I+")` asserts that `x` is an integer vector with at least one element and no missing values. This very simple domain specific language covers a large variety of frequent argument checks with only a few keystrokes. You choose what you like best. * [qassert](https://mllg.github.io/checkmate/reference/qassert) * [qassertr](https://mllg.github.io/checkmate/reference/qassert) ## checkmate as testthat extension To extend [testthat](https://cran.r-project.org/package=testthat), you need to IMPORT, DEPEND or SUGGEST on the `checkmate` package. Here is a minimal example: ```{r,eval=FALSE} # file: tests/test-all.R library(testthat) library(checkmate) # for testthat extensions test_check("mypkg") ``` Now you are all set and can use more than 30 new expectations in your tests. ```{r,eval=FALSE} test_that("checkmate is a sweet extension for testthat", { x = runif(100) expect_numeric(x, len = 100, any.missing = FALSE, lower = 0, upper = 1) # or, equivalent, using the lazy style: qexpect(x, "N100[0,1]") }) ``` ## Speed considerations In comparison with tediously writing the checks yourself in R (c.f. factorial example at the beginning of the vignette), R is sometimes a tad faster while performing checks on scalars. This seems odd at first, because checkmate is mostly written in C and should be comparably fast. Yet many of the functions in the `base` package are not regular functions, but primitives. While primitives jump directly into the C code, checkmate has to use the considerably slower `.Call` interface. As a result, it is possible to write (very simple) checks using only the base functions which, under some circumstances, slightly outperform checkmate. However, if you go one step further and wrap the custom check into a function to convenient re-use it, the performance gain is often lost (see benchmark 1). For larger objects the tide has turned because checkmate avoids many unnecessary intermediate variables. Also note that the quick/lazy implementation in `qassert`/`qtest`/`qexpect` is often a tad faster because only two arguments have to be evaluated (the object and the rule) to determine the set of checks to perform. Below you find some (probably unrepresentative) benchmark. But also note that this one here has been executed from inside `knitr` which is often the cause for outliers in the measured execution time. Better run the benchmark yourself to get unbiased results. ### Benchmark 1: Assert that `x` is a flag ```{r,dev="svg",fig.width=6,fig.height=4} library(ggplot2) library(microbenchmark) x = TRUE r = function(x, na.ok = FALSE) { stopifnot(is.logical(x), length(x) == 1, na.ok || !is.na(x)) } cm = function(x) assertFlag(x) cmq = function(x) qassert(x, "B1") mb = microbenchmark(r(x), cm(x), cmq(x)) print(mb) autoplot(mb) ``` ### Benchmark 2: Assert that `x` is a numeric of length 1000 with no missing nor NaN values ```{r,dev="svg",fig.width=6,fig.height=4} x = runif(1000) r = function(x) stopifnot(is.numeric(x) && length(x) == 1000 && all(!is.na(x) & x >= 0 & x <= 1)) cm = function(x) assertNumeric(x, len = 1000, any.missing = FALSE, lower = 0, upper = 1) cmq = function(x) qassert(x, "N1000[0,1]") mb = microbenchmark(r(x), cm(x), cmq(x)) print(mb) autoplot(mb) ``` ### Benchmark 3: Assert that `x` is a character vector with no missing values nor empty strings ```{r,dev="svg",fig.width=6,fig.height=4} x = sample(letters, 10000, replace = TRUE) r = function(x) stopifnot(is.character(x) && !any(is.na(x)) && all(nchar(x) > 0)) cm = function(x) assertCharacter(x, any.missing = FALSE, min.chars = 1) cmq = function(x) qassert(x, "S+[1,]") mb = microbenchmark(r(x), cm(x), cmq(x)) print(mb) autoplot(mb) ``` ### Benchmark 4: Assert that `x` is a data frame with no missing values ```{r,dev="svg",fig.width=6,fig.height=4} N = 10000 x = data.frame(a = runif(N), b = sample(letters[1:5], N, replace = TRUE), c = sample(c(FALSE, TRUE), N, replace = TRUE)) r = function(x) is.data.frame(x) && !any(sapply(x, function(x) any(is.na(x)))) cm = function(x) testDataFrame(x, any.missing = FALSE) cmq = function(x) qtest(x, "D") mb = microbenchmark(r(x), cm(x), cmq(x)) print(mb) autoplot(mb) # checkmate tries to stop as early as possible x$a[1] = NA mb = microbenchmark(r(x), cm(x), cmq(x)) print(mb) autoplot(mb) ``` ## Extending checkmate To extend checkmate a custom `check*` function has to be written. For example, to check for a square matrix one can re-use parts of checkmate and extend the check with additional functionality: ```{r} checkSquareMatrix = function(x, mode = NULL) { # check functions must return TRUE on success # and a custom error message otherwise res = checkMatrix(x, mode = mode) if (!isTRUE(res)) return(res) if (nrow(x) != ncol(x)) return("Must be square") return(TRUE) } # a quick test: X = matrix(1:9, nrow = 3) checkSquareMatrix(X) checkSquareMatrix(X, mode = "character") checkSquareMatrix(X[1:2, ]) ``` The respective counterparts to the `check`-function can be created using the constructors [makeAssertionFunction](https://mllg.github.io/checkmate/reference/makeAssertion), [makeTestFunction](https://mllg.github.io/checkmate/reference/makeTest) and [makeExpectationFunction](https://mllg.github.io/checkmate/reference/makeExpectation): ```{r} # For assertions: assert_square_matrix = assertSquareMatrix = makeAssertionFunction(checkSquareMatrix) print(assertSquareMatrix) # For tests: test_square_matrix = testSquareMatrix = makeTestFunction(checkSquareMatrix) print(testSquareMatrix) # For expectations: expect_square_matrix = makeExpectationFunction(checkSquareMatrix) print(expect_square_matrix) ``` Note that all the additional arguments `.var.name`, `add`, `info` and `label` are automatically joined with the function arguments of your custom check function. Also note that if you define these functions inside an R package, the constructors are called at build-time (thus, there is no negative impact on the runtime). ## Calling checkmate from C/C++ The package registers two functions which can be used in other packages' C/C++ code for argument checks. ```{c,eval=FALSE} SEXP qassert(SEXP x, const char *rule, const char *name); Rboolean qtest(SEXP x, const char *rule); ``` These are the counterparts to [qassert](https://mllg.github.io/checkmate/reference/qassert) and [qtest](https://mllg.github.io/checkmate/reference/qassert). Due to their simplistic interface, they perfectly suit the requirements of most type checks in C/C++. For detailed background information on the register mechanism, see the [Exporting C Code](http://r-pkgs.had.co.nz/src.html#clang) section in Hadley's Book "R Packages" or [WRE](https://cran.r-project.org/doc/manuals/r-release/R-exts.html#Registering-native-routines). Here is a step-by-step guide to get you started: 1. Add `checkmate` to your "Imports" and LinkingTo" sections in your DESCRIPTION file. 2. Create a stub file C source file which pulls in the provided C functions in order to compile them for your package. See example below. 3. Include the provided header file `` in each compilation unit where you want to use checkmate. ```{c,eval=FALSE} /* Example for (2), "checkmate_stub.c":*/ #include #include ``` ## Session Info For the sake of completeness, here the `sessionInfo()` for the benchmark (but remember the note before on `knitr` possibly biasing the results). ```{r} sessionInfo() ``` checkmate/inst/doc/checkmate.html0000644000176200001440000143614413006331417016545 0ustar liggesusers Checkmate

Checkmate

Michel Lang

2016-11-02

Ever used an R function that produced a not-very-helpful error message, just to discover after minutes of debugging that you simply passed a wrong argument?

Blaming the laziness of the package author for not doing such standard checks (in a dynamically typed language such as R) is at least partially unfair, as R makes theses types of checks cumbersome and annoying. Well, that’s how it was in the past.

Enter checkmate.

Virtually every standard type of user error when passing arguments into function can be caught with a simple, readable line which produces an informative error message in case. A substantial part of the package was written in C to minimize any worries about execution time overhead.

Intro

As a motivational example, consider you have a function to calculate the faculty of a natural number and the user may choose between using either the stirling approximation or R’s factorial function (which internally uses the gamma function). Thus, you have two arguments, n and method. Argument n must obviously be a positive natural number and method must be either "stirling" or "factorial". Here is a version of all the hoops you need to jump through to ensure that these simple requirements are met:

fact <- function(n, method = "stirling") {
  if (length(n) != 1)
    stop("Argument 'n' must have length 1")
  if (!is.numeric(n))
    stop("Argument 'n' must be numeric")
  if (is.na(n))
    stop("Argument 'n' may not be NA")
  if (is.double(n)) {
    if (is.nan(n))
      stop("Argument 'n' may not be NaN")
    if (is.infinite(n))
      stop("Argument 'n' must be finite")
    if (abs(n - round(n, 0)) > sqrt(.Machine$double.eps))
      stop("Argument 'n' must be an integerish value")
    n <- as.integer(n)
  }
  if (n < 0)
    stop("Argument 'n' must be >= 0")
  if (length(method) != 1)
    stop("Argument 'method' must have length 1")
  if (!is.character(method) || !method %in% c("stirling", "factorial"))
    stop("Argument 'method' must be either 'stirling' or 'factorial'")

  if (method == "factorial")
    factorial(n)
  else
    sqrt(2 * pi * n) * (n / exp(1))^n
}

And for comparison, here is the same function using checkmate:

fact <- function(n, method = "stirling") {
  assertCount(n)
  assertChoice(method, c("stirling", "factorial"))

  if (method == "factorial")
    factorial(n)
  else
    sqrt(2 * pi * n) * (n / exp(1))^n
}

Function overview

The functions can be split into four functional groups, indicated by their prefix.

If prefixed with assert, an error is thrown if the corresponding check fails. Otherwise, the checked object is returned invisibly. There are many different coding styles out there in the wild, but most R programmers stick to either camelBack or underscore_case. Therefore, checkmate offers all functions in both flavors: assert_count is just an alias for assertCount but allows you to retain your favorite style.

The family of functions prefixed with test always return the check result as logical value. Again, you can use test_count and testCount interchangeably.

Functions starting with check return the error message as a string (or TRUE otherwise) and can be used if you need more control and, e.g., want to grep on the returned error message.

expect is the last family of functions and is intended to be used with the testthat package. All performed checks are logged into the testthat reporter. Because testthat uses the underscore_case, the extension functions only come in the underscore style.

All functions are categorized into objects to check on the package help page.

In case you miss flexibility

You can use assert to perform multiple checks at once and throw an assertion if all checks fail.

Here is an example where we check that x is either of class foo or class bar:

f <- function(x) {
  assert(
    checkClass(x, "foo"),
    checkClass(x, "bar")
  )
}

Note that assert(, combine = "or") and assert(, combine = "and") allow to control the logical combination of the specified checks, and that the former is the default.

Argument Checks for the Lazy

The following functions allow a special syntax to define argument checks using a special format specification. E.g., qassert(x, "I+") asserts that x is an integer vector with at least one element and no missing values. This very simple domain specific language covers a large variety of frequent argument checks with only a few keystrokes. You choose what you like best.

checkmate as testthat extension

To extend testthat, you need to IMPORT, DEPEND or SUGGEST on the checkmate package. Here is a minimal example:

# file: tests/test-all.R
library(testthat)
library(checkmate) # for testthat extensions
test_check("mypkg")

Now you are all set and can use more than 30 new expectations in your tests.

test_that("checkmate is a sweet extension for testthat", {
  x = runif(100)
  expect_numeric(x, len = 100, any.missing = FALSE, lower = 0, upper = 1)
  # or, equivalent, using the lazy style:
  qexpect(x, "N100[0,1]")
})

Speed considerations

In comparison with tediously writing the checks yourself in R (c.f. factorial example at the beginning of the vignette), R is sometimes a tad faster while performing checks on scalars. This seems odd at first, because checkmate is mostly written in C and should be comparably fast. Yet many of the functions in the base package are not regular functions, but primitives. While primitives jump directly into the C code, checkmate has to use the considerably slower .Call interface. As a result, it is possible to write (very simple) checks using only the base functions which, under some circumstances, slightly outperform checkmate. However, if you go one step further and wrap the custom check into a function to convenient re-use it, the performance gain is often lost (see benchmark 1).

For larger objects the tide has turned because checkmate avoids many unnecessary intermediate variables. Also note that the quick/lazy implementation in qassert/qtest/qexpect is often a tad faster because only two arguments have to be evaluated (the object and the rule) to determine the set of checks to perform.

Below you find some (probably unrepresentative) benchmark. But also note that this one here has been executed from inside knitr which is often the cause for outliers in the measured execution time. Better run the benchmark yourself to get unbiased results.

Benchmark 1: Assert that x is a flag

library(ggplot2)
library(microbenchmark)

x = TRUE
r = function(x, na.ok = FALSE) { stopifnot(is.logical(x), length(x) == 1, na.ok || !is.na(x)) }
cm = function(x) assertFlag(x)
cmq = function(x) qassert(x, "B1")
mb = microbenchmark(r(x), cm(x), cmq(x))
print(mb)
## Unit: microseconds
##    expr   min     lq    mean median     uq     max neval cld
##    r(x) 6.297 6.6145 8.13963 6.8615 7.5025  35.795   100   b
##   cm(x) 1.603 1.7575 4.00172 1.9265 2.1035 169.700   100  a 
##  cmq(x) 1.029 1.1395 1.66973 1.2515 1.4320  34.927   100  a
autoplot(mb)

Benchmark 2: Assert that x is a numeric of length 1000 with no missing nor NaN values

x = runif(1000)
r = function(x) stopifnot(is.numeric(x) && length(x) == 1000 && all(!is.na(x) & x >= 0 & x <= 1))
cm = function(x) assertNumeric(x, len = 1000, any.missing = FALSE, lower = 0, upper = 1)
cmq = function(x) qassert(x, "N1000[0,1]")
mb = microbenchmark(r(x), cm(x), cmq(x))
print(mb)
## Unit: microseconds
##    expr    min      lq     mean  median     uq    max neval cld
##    r(x) 17.949 18.5330 20.23758 18.8110 19.346 43.093   100   b
##   cm(x)  6.295  6.4850  7.80275  6.8155  7.094 75.240   100  a 
##  cmq(x)  5.655  5.8005  6.67053  6.0675  6.245 25.272   100  a
autoplot(mb)

Benchmark 3: Assert that x is a character vector with no missing values nor empty strings

x = sample(letters, 10000, replace = TRUE)
r = function(x) stopifnot(is.character(x) && !any(is.na(x)) && all(nchar(x) > 0))
cm = function(x) assertCharacter(x, any.missing = FALSE, min.chars = 1)
cmq = function(x) qassert(x, "S+[1,]")
mb = microbenchmark(r(x), cm(x), cmq(x))
print(mb)
## Unit: microseconds
##    expr      min        lq       mean    median        uq      max neval
##    r(x) 1166.335 1168.1965 1303.36054 1184.8910 1399.4770 2069.396   100
##   cm(x)   28.874   29.6705   34.96495   30.4835   34.3575  229.213   100
##  cmq(x)   40.891   43.5615   48.42563   44.3015   49.7410   90.307   100
##  cld
##    b
##   a 
##   a
autoplot(mb)

Benchmark 4: Assert that x is a data frame with no missing values

N = 10000
x = data.frame(a = runif(N), b = sample(letters[1:5], N, replace = TRUE), c = sample(c(FALSE, TRUE), N, replace = TRUE))
r = function(x) is.data.frame(x) && !any(sapply(x, function(x) any(is.na(x))))
cm = function(x) testDataFrame(x, any.missing = FALSE)
cmq = function(x) qtest(x, "D")
mb = microbenchmark(r(x), cm(x), cmq(x))
print(mb)
## Unit: microseconds
##    expr    min      lq      mean   median       uq      max neval cld
##    r(x) 72.386 75.5275 105.74166 100.9505 105.4205 1312.374   100   b
##   cm(x) 18.697 19.5600  22.95351  20.4065  20.8585  177.918   100  a 
##  cmq(x) 14.255 14.5525  15.50605  14.8595  15.2120   59.144   100  a
autoplot(mb)

# checkmate tries to stop as early as possible
x$a[1] = NA
mb = microbenchmark(r(x), cm(x), cmq(x))
print(mb)
## Unit: nanoseconds
##    expr   min      lq     mean  median      uq     max neval cld
##    r(x) 64301 66390.0 91347.12 69911.0 95435.0 1224736   100   b
##   cm(x)  3916  4354.5  5843.08  4926.5  5341.0   23976   100  a 
##  cmq(x)   762   921.5  1333.89  1256.0  1621.5    3985   100  a
autoplot(mb)

Extending checkmate

To extend checkmate a custom check* function has to be written. For example, to check for a square matrix one can re-use parts of checkmate and extend the check with additional functionality:

checkSquareMatrix = function(x, mode = NULL) {
  # check functions must return TRUE on success
  # and a custom error message otherwise
  res = checkMatrix(x, mode = mode)
  if (!isTRUE(res))
    return(res)
  if (nrow(x) != ncol(x))
    return("Must be square")
  return(TRUE)
}

# a quick test:
X = matrix(1:9, nrow = 3)
checkSquareMatrix(X)
## [1] TRUE
checkSquareMatrix(X, mode = "character")
## [1] "Must store characters"
checkSquareMatrix(X[1:2, ])
## [1] "Must be square"

The respective counterparts to the check-function can be created using the constructors makeAssertionFunction, makeTestFunction and makeExpectationFunction:

# For assertions:
assert_square_matrix = assertSquareMatrix = makeAssertionFunction(checkSquareMatrix)
print(assertSquareMatrix)
## function (x, mode = NULL, .var.name = vname(x), add = NULL) 
## {
##     res = checkSquareMatrix(x, mode)
##     makeAssertion(x, res, .var.name, add)
## }
# For tests:
test_square_matrix = testSquareMatrix = makeTestFunction(checkSquareMatrix)
print(testSquareMatrix)
## function (x, mode = NULL) 
## {
##     identical(checkSquareMatrix(x, mode), TRUE)
## }
# For expectations:
expect_square_matrix = makeExpectationFunction(checkSquareMatrix)
print(expect_square_matrix)
## function (x, mode = NULL, info = NULL, label = vname(x)) 
## {
##     res = checkSquareMatrix(x, mode)
##     makeExpectation(x, res, info, label)
## }

Note that all the additional arguments .var.name, add, info and label are automatically joined with the function arguments of your custom check function. Also note that if you define these functions inside an R package, the constructors are called at build-time (thus, there is no negative impact on the runtime).

Calling checkmate from C/C++

The package registers two functions which can be used in other packages’ C/C++ code for argument checks.

SEXP qassert(SEXP x, const char *rule, const char *name);
Rboolean qtest(SEXP x, const char *rule);

These are the counterparts to qassert and qtest. Due to their simplistic interface, they perfectly suit the requirements of most type checks in C/C++.

For detailed background information on the register mechanism, see the Exporting C Code section in Hadley’s Book “R Packages” or WRE. Here is a step-by-step guide to get you started:

  1. Add checkmate to your “Imports” and LinkingTo" sections in your DESCRIPTION file.
  2. Create a stub file C source file which pulls in the provided C functions in order to compile them for your package. See example below.
  3. Include the provided header file <checkmate.h> in each compilation unit where you want to use checkmate.
/* Example for (2), "checkmate_stub.c":*/
#include <checkmate.h>
#include <checkmate_stub.c>

Session Info

For the sake of completeness, here the sessionInfo() for the benchmark (but remember the note before on knitr possibly biasing the results).

sessionInfo()
## R version 3.3.1 (2016-06-21)
## Platform: x86_64-pc-linux-gnu (64-bit)
## Running under: Arch Linux
## 
## locale:
##  [1] LC_CTYPE=de_DE.UTF-8       LC_NUMERIC=C              
##  [3] LC_TIME=de_DE.UTF-8        LC_COLLATE=C              
##  [5] LC_MONETARY=de_DE.UTF-8    LC_MESSAGES=de_DE.UTF-8   
##  [7] LC_PAPER=de_DE.UTF-8       LC_NAME=C                 
##  [9] LC_ADDRESS=C               LC_TELEPHONE=C            
## [11] LC_MEASUREMENT=de_DE.UTF-8 LC_IDENTIFICATION=C       
## 
## attached base packages:
## [1] stats     graphics  grDevices utils     datasets  methods   base     
## 
## other attached packages:
## [1] microbenchmark_1.4-2.1 ggplot2_2.1.0          checkmate_1.8.2       
## 
## loaded via a namespace (and not attached):
##  [1] Rcpp_0.12.7        knitr_1.14         magrittr_1.5      
##  [4] MASS_7.3-45        splines_3.3.1      munsell_0.4.3     
##  [7] colorspace_1.2-7   lattice_0.20-34    multcomp_1.4-6    
## [10] stringr_1.1.0      plyr_1.8.4         tools_3.3.1       
## [13] grid_3.3.1         gtable_0.2.0       TH.data_1.0-7     
## [16] htmltools_0.3.5    survival_2.40-1    yaml_2.1.13       
## [19] assertthat_0.1     rprojroot_1.1      digest_0.6.10     
## [22] tibble_1.2         Matrix_1.2-7.1     formatR_1.4       
## [25] codetools_0.2-15   evaluate_0.10      rmarkdown_1.1.9012
## [28] sandwich_2.3-4     stringi_1.1.2      scales_0.4.0      
## [31] backports_1.0.5    mvtnorm_1.0-5      zoo_1.7-13
checkmate/inst/include/0000755000176200001440000000000012762012005014571 5ustar liggesuserscheckmate/inst/include/checkmate.h0000644000176200001440000000057012762012005016670 0ustar liggesusers#ifndef _CHECKMATE_H_ #define _CHECKMATE_H_ #include #include #include #include #include #ifdef __cplusplus extern "C" { #endif Rboolean attribute_hidden qtest(SEXP x, const char *rule); SEXP attribute_hidden qassert(SEXP x, const char *rule, const char *name); #ifdef __cplusplus } #endif #endif checkmate/inst/include/checkmate_stub.c0000644000176200001440000000104112762012005017712 0ustar liggesusers#include "checkmate.h" Rboolean attribute_hidden qtest(SEXP x, const char *rule) { static Rboolean(*fun)(SEXP, const char *) = NULL; if (fun == NULL) fun = (Rboolean(*)(SEXP, const char *)) R_GetCCallable("checkmate", "qtest"); return fun(x, rule); } SEXP attribute_hidden qassert(SEXP x, const char *rule, const char *name) { static SEXP(*fun)(SEXP, const char *, const char *) = NULL; if (fun == NULL) fun = (SEXP(*)(SEXP, const char *, const char *)) R_GetCCallable("checkmate", "qassert"); return fun(x, rule, name); } checkmate/tests/0000755000176200001440000000000012762012005013333 5ustar liggesuserscheckmate/tests/testthat/0000755000176200001440000000000013006324057015200 5ustar liggesuserscheckmate/tests/testthat/test_checkCharacter.R0000644000176200001440000000267512767766620021311 0ustar liggesuserscontext("checkCharacter") test_that("checkCharacter", { myobj = c("a", "b") expect_succ_all(Character, myobj) myobj = 0 expect_fail_all(Character, myobj) expect_true(testCharacter(character(0))) expect_false(testCharacter(NULL)) expect_true(testCharacter("a")) expect_false(testCharacter(1)) expect_true(testCharacter(NA)) expect_true(testCharacter(NA_character_)) expect_true(testCharacter("a", min.chars = 1)) expect_false(testCharacter("a", min.chars = 2)) # treat NA_character_ as zero-length string expect_true(testCharacter(NA_character_, min.chars = 0)) expect_false(testCharacter(NA_character_, min.chars = 1)) expect_false(testCharacter(NA, min.chars = 1)) x = c("abba", "baab") expect_true(testCharacter(x, pattern="a")) expect_true(testCharacter(x, pattern="ab")) expect_false(testCharacter(x, pattern="aa")) expect_false(testCharacter(x, pattern="^ab")) expect_true(testCharacter(x, pattern="AB", ignore.case=TRUE)) expect_true(testCharacter(x, pattern="AB", ignore.case=TRUE)) expect_false(testCharacter(x, pattern="AB", ignore.case=FALSE)) expect_false(testCharacter(x, pattern="AB", ignore.case=FALSE)) expect_true(testCharacter(x, pattern="a+")) expect_false(testCharacter(x, fixed="a+")) x = letters[1:3] expect_true(testCharacter(x, any.missing=FALSE, min.len=1L, max.len=3L)) expect_false(testCharacter(x, any.missing=FALSE, len=5)) expect_error(assertCharacter(1), "character") }) checkmate/tests/testthat/test_qassertr.R0000644000176200001440000000426012762012005020223 0ustar liggesuserscontext("qtestr") expect_succ_all = function(x, rules) { xn = deparse(substitute(x)) expect_true(qtestr(x, rules), info = sprintf("rules: %s", paste0(rules, collapse=",")), label = xn) expect_identical(qassertr(x, rules), x, info = sprintf("rules: %s", paste0(rules, collapse=",")), label = xn) expect_expectation_successful(qexpectr(x, rules), info = sprintf("rules: %s", paste0(rules, collapse=",")), label = xn) } expect_fail_all = function(x, rules, pattern = NULL) { xn = deparse(substitute(x)) expect_false(qtestr(x, rules), info = sprintf("rules: %s", paste0(rules, collapse=",")), label = xn) expect_error(qassertr(x, rules), regex = pattern, info = sprintf("rules: %s", paste0(rules, collapse=",")), label = xn) expect_expectation_failed(qexpectr(x, rules), info = sprintf("rules: %s", paste0(rules, collapse=",")), label = xn) } test_that("qassertr / qtestr", { x = list(a = 1:10, b = rnorm(10)) expect_succ_all(x, "n+") expect_succ_all(x, "n10") expect_succ_all(x, "n>=1") expect_fail_all(x, "i+") expect_fail_all(x, "l") x = list(a = NULL, b = 10) expect_succ_all(x, "*") expect_fail_all(x, "0") expect_fail_all(x, "n") x = list(a = NULL, b = NULL) expect_succ_all(x, "0") expect_fail_all(x, "0+") x = list() expect_succ_all(x, "n+") expect_succ_all(x, "0+") x = list(1, 2) expect_fail_all(x, "S1", pattern = "string") x = list(1:10, NULL) expect_succ_all(x, c("v", "l", "0")) rules = c("v", "l") expect_fail_all(x, c("v", "l"), pattern = "One of") expect_succ_all(iris, c("f", "n")) expect_fail_all(iris, c("s", "n"), pattern = "One of") x = NULL expect_error(qassertr(x, "x"), "list or data.frame") expect_error(qtestr(x, "x"), "list or data.frame") }) test_that("qtestr / depth", { x = list(letters, 1:10, list(letters, 2:3, runif(10))) rules = c("v", "l") expect_true(qtestr(x, rules, depth = 1L)) expect_true(qtestr(x, rules, depth = 2L)) expect_true(qtestr(x, rules, depth = 3L)) x[[3]][[2]] = iris expect_true(qtestr(x, rules, depth = 1L)) expect_true(qtestr(x, c(rules, "d"), depth = 1L)) expect_false(qtestr(x, rules, depth = 2L)) expect_false(qtestr(x, rules, depth = 3L)) }) checkmate/tests/testthat/test_checkCount.R0000644000176200001440000000132312762012005020442 0ustar liggesuserscontext("checkCount") test_that("checkCount", { myobj = 1 expect_succ_all(Count, myobj) myobj = -1 expect_fail_all(Count, myobj) expect_false(testCount(integer(0))) expect_false(testCount(NULL)) expect_false(testCount(FALSE)) expect_false(testCount(TRUE)) expect_true(testCount(0L)) expect_false(testCount(0L, positive = TRUE)) expect_true(testCount(1L, positive = TRUE)) expect_true(testCount(1)) expect_true(testCount(0)) expect_false(testCount(-1)) expect_false(testCount(0.5)) expect_false(testCount(NA_integer_)) expect_true(testCount(NA, na.ok = TRUE)) expect_true(testCount(NA_integer_, na.ok = TRUE)) expect_false(testCount(1:2)) expect_error(assertCount(-1), ">= 0") }) checkmate/tests/testthat/test_AssertCollection.R0000644000176200001440000000212612762012005021633 0ustar liggesuserscontext("AssertCollection") test_that("Collection closure wors", { coll = makeAssertCollection() expect_is(coll, "AssertCollection") expect_output(print(coll), "Empty collection") expect_equal(coll$getMessages(), character(0L)) expect_true(coll$isEmpty()) coll$push("testing") expect_equal(coll$getMessages(), "testing") expect_false(coll$isEmpty()) expect_output(print(coll), "Collection of 1 assertion") coll$push("foo") expect_output(print(coll), "Collection of 2 assertions") expect_equal(coll$getMessages(), c("testing", "foo")) }) test_that("Reporter works", { coll = makeAssertCollection() expect_true(reportAssertions(coll)) coll$push("foo") coll$push("bar") expect_error(reportAssertions(coll), "foo") expect_error(reportAssertions(coll), "bar") }) test_that("asserts push to collection", { coll = makeAssertCollection() findme = "a" assertString(findme, add = coll) expect_true(coll$isEmpty()) expect_true(reportAssertions(coll)) assertNumeric(findme, add = coll) expect_false(coll$isEmpty()) expect_error(reportAssertions(coll), "findme") }) checkmate/tests/testthat/test_checkNull.R0000644000176200001440000000037212762012005020267 0ustar liggesuserscontext("checkNull") test_that("checkNull", { myobj = NULL expect_succ_all(Null, myobj) myobj = TRUE expect_fail_all(Null, myobj) expect_false(testNull(integer(0))) expect_true(testNull(NULL)) expect_error(assertNull(-1), "NULL") }) checkmate/tests/testthat/test_interoperability.R0000644000176200001440000000160312762012005021742 0ustar liggesuserscontext("Interoperability") test_that("data.table is supported", { skip_if_not_installed("data.table") library(data.table) myobj = as.data.table(iris) expect_succ_all(DataFrame, myobj) expect_true(testDataFrame(myobj, nrow = 150, min.cols = 2, any.missing = FALSE, col.names = "strict")) expect_true(testDataFrame(data.table())) }) test_that("tibble is supported", { skip_if_not_installed("tibble") library(tibble) myobj = as_tibble(iris) expect_succ_all(DataFrame, myobj) expect_true(testDataFrame(myobj, nrow = 150, min.cols = 2, any.missing = FALSE, col.names = "strict")) expect_true(testDataFrame(data_frame())) }) test_that("magrittr is supported", { skip_if_not_installed("magrittr") library(magrittr) x = runif(10) expect_identical(x %>% assert_numeric(lower = 0, upper = 1), x) expect_identical(iris %>% assert_data_frame(min.rows = 1) %>% ncol, 5L) }) checkmate/tests/testthat/test_messages.R0000644000176200001440000000035512762012005020167 0ustar liggesuserscontext("generated messages") test_that("No extra strings attached to generated error messages", { foo = function(XX) assertFlag(XX) expect_error(foo(iris), "^Assertion on 'XX'") expect_error(foo(iris), "not 'data.frame'\\.$") }) checkmate/tests/testthat/test_checkDataTable.R0000644000176200001440000000237612762012005021204 0ustar liggesuserscontext("checkDataTable") test_that("checkDataTable", { skip_if_not_installed("data.table") library(data.table) dt = as.data.table(iris) expect_succ_all("DataTable", dt) expect_fail_all("DataTable", iris) expect_true(testDataTable(dt, min.rows = 1, ncols = 5)) expect_false(testDataTable(dt, min.rows = 1000, ncols = 5)) expect_true(testDataTable(dt, key = character(0))) expect_true(testDataTable(dt, index = character(0))) setkeyv(dt, "Species") expect_true(testDataTable(dt, key = "Species")) expect_false(testDataTable(dt, index = "Species")) dt = as.data.table(iris) setkeyv(dt, "Species", physical = FALSE) expect_false(testDataTable(dt, key = "Species")) expect_true(testDataTable(dt, index = "Species")) dt = as.data.table(iris) setkeyv(dt, c("Petal.Width", "Petal.Length"), physical = TRUE) setkeyv(dt, c("Sepal.Length", "Sepal.Width"), physical = FALSE) expect_true(testDataTable(dt, key = c("Petal.Width", "Petal.Length"), index = c("Sepal.Width", "Sepal.Length"))) expect_error(testDataTable(dt, key = 1), "string") expect_error(testDataTable(dt, index = 1), "string") expect_error(assertDataTable(dt, key = "Species"), "primary keys") expect_error(assertDataTable(dt, index = "Species"), "secondary keys") }) checkmate/tests/testthat/test_checkSubset.R0000644000176200001440000000144513006324057020631 0ustar liggesuserscontext("checkSubset") test_that("checkSubset", { myobj = letters[1:3] expect_succ_all(Subset, myobj, letters) myobj = 1:2 expect_fail_all(Subset, myobj, letters) expect_false(testSubset(character(0), letters, empty.ok = FALSE)) expect_true(testSubset(character(0), letters, empty.ok = TRUE)) expect_false(testSubset(NULL, letters, empty.ok = FALSE)) expect_true(testSubset(character(0), letters, empty.ok = TRUE)) expect_true(testSubset(factor("a"), letters)) expect_true(testSubset(factor("a"), factor(letters))) expect_true(testSubset(1L, 1:10)) expect_true(testSubset(3:4, 1:10)) expect_false(testSubset("ab", letters)) expect_false(testSubset(NA_integer_, 1:10)) expect_error(assertSubset(-1, 1:2), "subset of") expect_error(assertSubset(1L, list()), "atomic") }) checkmate/tests/testthat/test_anyNaN.R0000644000176200001440000000126312762012005017543 0ustar liggesuserscontext("anyNaN") test_that("anyNaN", { xb = logical(10) xi = integer(10) xd = double(10) xc = complex(10) xl = as.list(1:10) xm = matrix(1:9, 3) xf = data.frame(a=1:5, b=1:5) expect_false(anyNaN(NULL)) expect_false(anyNaN(mean)) expect_false(anyNaN(double(0))) expect_false(anyNaN(xb)) expect_false(anyNaN(xi)) expect_false(anyNaN(xd)) expect_false(anyNaN(xc)) expect_false(anyNaN(xl)) expect_false(anyNaN(xm)) expect_false(anyNaN(xf)) xd[5] = xc[5] = xf$b[3] = NaN xl[5] = NaN expect_true(anyNaN(xd)) expect_true(anyNaN(xc)) expect_true(anyNaN(xl)) expect_true(anyNaN(xf)) x = list(1, list(1, list(1, NaN))) expect_true(anyNaN(x)) }) checkmate/tests/testthat/test_checkScalarNA.R0000644000176200001440000000057012762012005021001 0ustar liggesuserscontext("checkScalarNA") test_that("checkScalarNA", { expect_succ_all("ScalarNA", NA) expect_fail_all("ScalarNA", 1) expect_true(testScalarNA(NA_real_)) expect_false(testScalarNA(1)) expect_false(testScalarNA(rep(NA_character_, 2))) expect_expectation_successful(expect_scalar_na(NA), label = NULL) expect_error(assertScalarNA(integer(0)), "missing value") }) checkmate/tests/testthat/test_checkFilesystem.R0000644000176200001440000000504212762012005021500 0ustar liggesuserscontext("checkFile") td = tempfile("checkFile") dir.create(td, recursive=TRUE) fn = file.path(td, "myfile.ext") dn = file.path(td, "dir") ff = file.path(td, "xxx") file.create(fn) dir.create(dn) test_that("checkFile", { myobj = fn expect_succ_all(FileExists, myobj) myobj = ff expect_fail_all(FileExists, myobj) expect_false(testFileExists(character(0))) expect_false(testFileExists(NULL)) expect_false(testFileExists(dn)) expect_error(assertFileExists(character(0)), "provided") expect_error(assertFileExists(ff), "exist") expect_error(assertFileExists(dn)) expect_succ_all(FileExists, fn, extension = "ext") expect_succ_all(FileExists, fn, extension = c("foo", "ext")) expect_fail_all(FileExists, fn, extension = "foo") }) test_that("check_directory", { myobj = dn expect_succ_all(DirectoryExists, myobj) myobj = ff expect_fail_all(DirectoryExists, myobj) expect_false(testDirectoryExists(character(0))) expect_false(testDirectoryExists(fn)) expect_error(assertDirectoryExists(character(0)), "provided") expect_error(assertDirectoryExists(ff), "exist") expect_error(assertDirectoryExists(fn)) }) test_that("check_access", { myobj = R.home() expect_succ_all(Access, myobj, "r") if (.Platform$OS.type != "windows") { Sys.chmod(fn, "0000") expect_true(testAccess(fn, "")) expect_false(testAccess(fn, "r")) expect_false(testAccess(fn, "w")) expect_false(testAccess(fn, "x")) Sys.chmod(fn, "0700") expect_true(testAccess(fn, "")) expect_true(testAccess(fn, "r")) expect_true(testAccess(fn, "w")) expect_true(testAccess(fn, "x")) Sys.chmod(fn, "0600") expect_true(testAccess(fn, "")) expect_true(testAccess(fn, "r")) expect_true(testAccess(fn, "rw")) expect_false(testAccess(fn, "rx")) expect_false(testAccess(fn, "wx")) expect_error(testAccess(fn, "a")) expect_error(testAccess(fn, "rrr")) } }) test_that("check_path_for_output", { myobj = ff expect_succ_all(PathForOutput, myobj) myobj = fn expect_fail_all(PathForOutput, myobj) expect_false(testPathForOutput(character(0))) expect_false(testPathForOutput(NULL)) expect_error(assertPathForOutput(character(0)), "path provided") expect_identical(assertPathForOutput(c("a", "b")), c("a", "b")) expect_identical(assertPathForOutput(ff), ff) expect_error(assertPathForOutput(fn), "exist") expect_identical(assertPathForOutput(fn, overwrite = TRUE), fn) expect_true(testPathForOutput(c(fn, ff, dn), overwrite = TRUE)) expect_false(testPathForOutput(c(fn, ff, dn), overwrite = FALSE)) }) checkmate/tests/testthat/test_checkNames.R0000644000176200001440000000664112762012005020425 0ustar liggesuserscontext("checkNames") test_that("checkNames", { nn = letters[1:3] expect_succ_all(Names, nn) expect_fail_all(Names, nn, type = "unnamed") expect_true(testNames(character(0))) expect_false(testNames(NULL)) expect_false(testNames(integer(0))) x = c("a", ".a") expect_true(testNames(x)) expect_true(testNames(x, "unique")) expect_true(testNames(x, "strict")) expect_false(testNames(1)) expect_false(testNames(NA_character_)) expect_false(testNames(NA_integer_)) expect_false(testNames("")) x = c("a", "a") expect_true(testNames(x)) expect_false(testNames(x, "unique")) expect_true(testNames("x", type = "strict")) expect_true(testNames("..x", type = "strict")) expect_true(testNames("x_1", type = "strict")) expect_true(testNames("x.", type = "strict")) expect_false(testNames("1", type = "strict")) expect_false(testNames(".1", type = "strict")) expect_false(testNames("..1", type = "strict")) expect_false(testNames("x ", type = "strict")) expect_false(testNames("ä", type = "strict")) expect_error(assertNames(c("a", "a"), "unique"), "unique") x = c("a", "1") expect_error(assertNames(x, "strict"), "naming rules") }) test_that("argument 'type' is checked", { expect_error(checkNames("x", type = 1), "string") expect_error(checkNames("x", type = NA_character_), "missing") }) test_that("checkNames / subset.of", { x = 1:3 names(x) = letters[1:3] expect_true(testNames(names(x), subset.of = letters[1:3])) expect_true(testNames(names(x), subset.of = letters[3:1])) expect_true(testNames(names(x), subset.of = letters)) expect_false(testNames(names(x), subset.of = letters[1:2])) expect_false(testNames(names(x), subset.of = character(0))) expect_false(testNames(NULL, subset.of = character(0))) expect_true(testNames(character(0), subset.of = character(0))) expect_true(testNames(character(0), subset.of = NULL)) }) test_that("checkNames / identical.to", { x = 1:3 names(x) = letters[1:3] expect_true(testNames(names(x), identical.to = letters[1:3])) expect_false(testNames(names(x), identical.to = letters[3:1])) expect_false(testNames(names(x), identical.to = letters)) expect_false(testNames(names(x), identical.to = letters[1:2])) expect_false(testNames(names(x), identical.to = character(0))) expect_false(testNames(NULL, identical.to = character(0))) expect_true(testNames(character(0), identical.to = character(0))) expect_true(testNames(character(0), identical.to = NULL)) expect_false(testNames(NULL, identical.to = NULL)) }) test_that("checkNames / permutation.of", { x = 1:3 names(x) = letters[1:3] expect_true(testNames(names(x), permutation.of = letters[1:3])) expect_true(testNames(names(x), permutation.of = letters[3:1])) expect_false(testNames(names(x), permutation.of = letters)) expect_false(testNames(names(x), permutation.of = letters[1:2])) expect_false(testNames(names(x), permutation.of = character(0))) expect_false(testNames(NULL, permutation.of = character(0))) expect_true(testNames(character(0), permutation.of = character(0))) expect_true(testNames(character(0), permutation.of = NULL)) expect_false(testNames(NULL, permutation.of = NULL)) }) test_that("checkNames / errors are useful", { foo = matrix(1:9) expect_error( assertNames(colnames(foo), permutation.of = letters), "colnames\\(foo\\)" ) expect_error( assertNames(rownames(foo), permutation.of = letters), "rownames\\(foo\\)" ) }) checkmate/tests/testthat/test_checkScalar.R0000644000176200001440000000076112762012005020564 0ustar liggesuserscontext("checkScalar") test_that("checkScalar", { myobj = "a" expect_succ_all(Scalar, myobj) myobj = 1:2 expect_fail_all(Scalar, myobj) expect_true(testScalar(TRUE)) expect_true(testScalar(1L)) expect_true(testScalar(1)) expect_true(testScalar(1+1i)) expect_false(testScalar(list(1))) expect_false(testScalar(NA, na.ok = FALSE)) expect_true(testScalar(NA, na.ok = TRUE)) expect_error(assertScalar(integer(0)), "length 1") expect_error(assertScalar(iris), "scalar") }) checkmate/tests/testthat/test_checkString.R0000644000176200001440000000173412762012005020626 0ustar liggesuserscontext("checkString") test_that("checkString", { expect_succ_all(String, "a") expect_succ_all(String, "") expect_fail_all(String, "", min.chars = 1) expect_fail_all(String, 1L) expect_succ_all(String, NA_character_, na.ok = TRUE, min.chars = 99) expect_succ_all(String, "xxxfooxxx", pattern = "foo") expect_succ_all(String, "xxxfooxxx", fixed = "foo") expect_fail_all(String, "xxxfooxxx", pattern = "bar") expect_fail_all(String, "xxxfooxxx", fixed = "bar") expect_succ_all(String, "xxxfooxxx", pattern = "FOO", ignore.case = TRUE) expect_fail_all(String, "xxxfooxxx", fixed = "FOO", ignore.case = FALSE) expect_false(testString(character(0))) expect_false(testString(NULL)) expect_true(testString("")) expect_true(testString("foo")) expect_true(testString(NA, na.ok = TRUE)) expect_false(testString(NA_character_)) expect_true(testString(NA_character_, na.ok = TRUE)) expect_true(testString(NA, na.ok = TRUE)) expect_error(assertString(1)) }) checkmate/tests/testthat/test_matchArg.R0000644000176200001440000000121312762012005020100 0ustar liggesuserscontext("matchArg") test_that("matchArg", { x = c("pearson", "kendall", "spearman") choices = x expect_equal(matchArg(x, choices), choices[1]) expect_equal(matchArg(x, choices, several.ok = TRUE), choices) x = substr(x, 1, 1) expect_equal(matchArg(x[2], choices, several.ok = FALSE), choices[2]) expect_equal(matchArg(x[c(1, 3)], choices, several.ok = TRUE), choices[c(1, 3)]) expect_error(matchArg(1, 1:10), "character") expect_error(matchArg(1, letters), "character") expect_error(matchArg(letters, 1:10), "character") expect_error(matchArg(x[1:2], choices), "length") expect_error(matchArg(x[0], choices), "length 0") }) checkmate/tests/testthat/test_checkComplex.R0000644000176200001440000000121212762012005020756 0ustar liggesuserscontext("checkComplex") test_that("checkComplex", { myobj = 1+1i expect_succ_all(Complex, myobj) myobj = 1 expect_fail_all(Complex, myobj) expect_true(testComplex(complex(0L))) expect_false(testComplex(NULL)) expect_false(testComplex(TRUE)) expect_true(testComplex(NA)) expect_false(testComplex(NA, any.missing = FALSE)) expect_false(testComplex(NA, all.missing = FALSE)) expect_true(testComplex(NA_complex_)) expect_true(testComplex(1+1i)) expect_true(testComplex(as.complex(Inf))) expect_true(testComplex(c(1+1i, 2+1i), any.missing = FALSE, min.len = 1L, max.len = 3L)) expect_error(assertComplex(1), "complex") }) checkmate/tests/testthat/test_makeFunction.R0000644000176200001440000000212112762012005020774 0ustar liggesuserscontext("makeXFunction") test_that("makeAssertion", { x = assertFlag y = makeAssertionFunction(checkFlag, c.fun = "c_check_flag") expect_identical(formals(x), formals(y)) expect_equal(body(x), body(y)) x = assertList y = makeAssertionFunction(checkList) expect_identical(formals(x), formals(y)) expect_equal(body(x), body(y)) }) test_that("makeTest", { x = testFlag y = makeTestFunction(checkFlag, c.fun = "c_check_flag") expect_identical(formals(x), formals(y)) expect_equal(body(x), body(y)) x = testList y = makeTestFunction(checkList) expect_identical(formals(x), formals(y)) expect_equal(body(x), body(y)) x = testFlag y = function(x) makeTest(checkFlag(x)) expect_equal(x(TRUE), y(TRUE)) expect_equal(x(FALSE), y(FALSE)) }) test_that("makeExpectation", { x = expect_flag y = makeExpectationFunction(checkFlag, c.fun = "c_check_flag") expect_identical(formals(x), formals(y)) expect_equal(body(x), body(y)) x = expect_list y = makeExpectationFunction(checkList) expect_identical(formals(x), formals(y)) expect_equal(body(x), body(y)) }) checkmate/tests/testthat/test_include.R0000644000176200001440000000100612762012005017775 0ustar liggesuserscontext("registered c functions") test_that("include of registered C functions works", { skip_on_cran() if (length(find.package("checkmate.test.include", quiet = TRUE)) == 0L) { requireNamespace("devtools") devtools::install_github("mllg/checkmate-test-include") } library(checkmate.test.include) expect_true(reexported_qtest(1, "N1")) expect_false(reexported_qtest(1, "b")) x = pi expect_identical(reexported_qassert(x, "N1"), x) expect_error(reexported_qassert(x, "b", "foo"), "foo") }) checkmate/tests/testthat/test_checkNumeric.R0000644000176200001440000000351512762012005020761 0ustar liggesuserscontext("checkNumeric") test_that("checkNumeric", { myobj = 1 expect_succ_all(Numeric, myobj) myobj = "a" expect_fail_all(Numeric, myobj) expect_true(testNumeric(integer(0))) expect_false(testNumeric(NULL)) expect_false(testNumeric(TRUE)) expect_false(testNumeric(FALSE)) expect_true(testNumeric(NA_character_)) expect_true(testNumeric(NA_real_)) expect_true(testNumeric(NaN)) expect_false(testNumeric(NA_real_, any.missing = FALSE)) expect_false(testNumeric(NA_real_, all.missing = FALSE)) expect_false(testNumeric(NaN, any.missing = FALSE)) expect_false(testNumeric(NaN, all.missing = FALSE)) expect_true(testNumeric(1L)) expect_true(testNumeric(1)) expect_true(testNumeric(Inf)) expect_true(testNumeric(-Inf)) expect_identical(assertNumeric(1:2, finite = TRUE), 1:2) expect_error(assertNumeric(c(1, Inf), finite = TRUE), "finite") expect_error(assertNumeric(c(1, -Inf), finite = TRUE), "finite") expect_true(testNumeric(1:3, any.missing=FALSE, min.len=1L, max.len=3L)) expect_false(testNumeric(1:3, any.missing=FALSE, len=5)) expect_true(testNumeric(1:3, lower = 1L, upper = 3L)) expect_false(testNumeric(1:3, lower = 5)) expect_error(assertNumeric("a"), "numeric") }) test_that("bounds are checked", { expect_error(checkNumeric(1, lower = "a"), "number") expect_error(checkNumeric(1, lower = 1:2), "number") expect_error(checkNumeric(1, lower = NA_real_), "missing") expect_error(checkNumeric(1, upper = "a"), "number") expect_error(checkNumeric(1, upper = 1:2), "number") expect_error(checkNumeric(1, upper = NA_real_), "missing") }) test_that("bounds of vectors with only missings are not checked", { expect_true(checkNumeric(NA, lower = 1)) expect_true(checkNumeric(NA_character_, upper = 10)) expect_fail_all(Numeric, 0:5, lower = 1L) expect_fail_all(Numeric, 5:15, upper = 10L) }) checkmate/tests/testthat/test_wf.R0000644000176200001440000000166212762012005016776 0ustar liggesuserscontext("wf / wl") test_that("wf / wl", { x = c(FALSE, TRUE, FALSE, TRUE) expect_equal(wf(x), 2L) expect_equal(wl(x), 4L) x = c(NA, TRUE, NA, TRUE, NA) expect_equal(wf(x), 2L) expect_equal(wl(x), 4L) x = logical(0L) expect_equal(wf(x), integer(0L)) expect_equal(wl(x), integer(0L)) expect_equal(wf(x), integer(0L)) expect_equal(wl(x), integer(0L)) x = c(NA, NA) expect_equal(wf(x), integer(0L)) expect_equal(wl(x), integer(0L)) x = setNames(c(NA, FALSE, TRUE, FALSE, TRUE, FALSE, NA), letters[1:7]) expect_identical(wf(x, TRUE), setNames(3L, "c")) expect_identical(wf(x, FALSE), 3L) expect_identical(wl(x), setNames(5L, "e")) expect_identical(wl(x, FALSE), 5L) expect_equal(wf(logical(0)), integer(0)) expect_equal(wl(logical(0)), integer(0)) expect_error(wf(42), "logical") expect_error(wl(42), "logical") expect_error(wf(NA, iris), "use.names") expect_error(wl(NA, iris), "use.names") }) checkmate/tests/testthat/test_checkInteger.R0000644000176200001440000000203412762012005020747 0ustar liggesuserscontext("checkInteger") test_that("checkInteger", { myobj = 1L expect_succ_all(Integer, myobj) myobj = 1 expect_fail_all(Integer, myobj) expect_true(testInteger(integer(0))) expect_false(testInteger(NULL)) expect_false(testInteger(TRUE)) expect_false(testInteger(FALSE)) expect_true(testInteger(NA)) expect_false(testInteger(NA, any.missing = FALSE)) expect_false(testInteger(NA, all.missing = FALSE)) expect_true(testInteger(1L)) expect_true(testInteger(1:3, any.missing = FALSE, min.len = 1L, max.len = 3L)) expect_false(testInteger(1:3, any.missing = FALSE, len = 5)) expect_true(testInteger(1:3, lower = 1L, upper = 3L)) expect_false(testInteger(1:3, lower = 5)) expect_false(testInteger(1:3, upper = 1)) expect_error(assertInteger(1), "integer") }) test_that("bounds of vectors with only missings are not checked", { expect_true(checkInteger(NA, lower = 1)) expect_true(checkInteger(NA_character_, upper = 10)) expect_fail_all(Integer, 0L, lower = 1L) expect_fail_all(Integer, 100L, upper = 10L) }) checkmate/tests/testthat/test_checkMatrix.R0000644000176200001440000000632412762012005020624 0ustar liggesuserscontext("checkMatrix") test_that("checkMatrix", { myobj = matrix(1:9, 3) expect_succ_all(Matrix, myobj) myobj = TRUE expect_fail_all(Matrix, myobj) x = matrix(1:9, 3) expect_true(testMatrix(x)) expect_true(testMatrix(matrix(nrow=0, ncol=0))) expect_false(testMatrix(NULL)) x[2,2] = NA expect_true(testMatrix(x)) expect_false(testMatrix(x, any.missing = FALSE)) xl = matrix(TRUE) xi = matrix(1L) xr = matrix(1.) xs = matrix("a") xc = matrix(1+1i) xx = array(list(1, 1), dim = c(1, 2)) xe = matrix(nrow = 0, ncol = 0); storage.mode(xe) = "double" expect_true(testMatrix(xl, "logical")) expect_true(testMatrix(xi, "integer")) expect_true(testMatrix(xr, "double")) expect_true(testMatrix(xe, "double")) expect_true(testMatrix(xr, "numeric")) expect_true(testMatrix(xc, "complex")) expect_true(testMatrix(xs, "character")) expect_true(testMatrix(xx, "list")) expect_false(testMatrix(xs, "logical")) expect_false(testMatrix(xs, "integer")) expect_false(testMatrix(xs, "double")) expect_false(testMatrix(xe, "logical")) expect_false(testMatrix(xs, "numeric")) expect_false(testMatrix(xs, "complex")) expect_false(testMatrix(xl, "character")) expect_false(testMatrix(xx, "numeric")) expect_false(testMatrix(xx, "atomic")) expect_true(testMatrix(xi, "integerish")) expect_true(testMatrix(xr, "integerish")) expect_false(testMatrix(xi+0.1, "integerish")) expect_true(testMatrix(x, min.rows = 1, min.cols = 1)) expect_true(testMatrix(x, nrows = 3, ncols = 3)) expect_true(testMatrix(xx, nrows = 1, ncols = 2)) expect_true(testMatrix(xe, nrows = 0, ncols = 0)) expect_false(testMatrix(x, min.rows = 5)) expect_false(testMatrix(x, min.cols = 5)) expect_false(testMatrix(x, nrows = 5)) expect_false(testMatrix(x, ncols = 5)) expect_false(testMatrix(x, row.names = "named")) expect_false(testMatrix(x, col.names = "named")) rownames(x) = letters[1:3]; colnames(x) = NULL expect_true(testMatrix(x, row.names = "named")) expect_false(testMatrix(x, col.names = "named")) colnames(x) = letters[1:3]; rownames(x) = NULL expect_false(testMatrix(x, row.names = "named")) expect_true(testMatrix(x, col.names = "named")) colnames(x) = rownames(x) = letters[1:3] expect_true(testMatrix(x, row.names = "named")) expect_true(testMatrix(x, col.names = "named")) # named and unnamed is the same for "empty" matricies expect_true(testMatrix(xe, row.names = "unnamed")) expect_true(testMatrix(xe, col.names = "unnamed")) expect_true(testMatrix(xe, row.names = "strict")) expect_true(testMatrix(xe, col.names = "strict")) expect_error(assertMatrix(iris), "matrix") expect_error(assertMatrix(matrix(), min.rows = 99), "99") }) test_that("dimension arugments are checked", { x = matrix(1) expect_error(checkMatrix(x, min.rows = 1.2), "count") expect_error(checkMatrix(x, min.rows = NA_integer_), "missing") expect_error(checkMatrix(x, min.rows = -1), ">= 0") }) test_that("dimensions are reported correctly", { x = matrix(1:42, ncol = 1) expect_true(grepl(42, checkMatrix(x, nrows = 43))) expect_true(grepl(42, checkMatrix(x, min.rows = 43))) x = t(x) expect_true(grepl(42, checkMatrix(x, ncols = 43))) expect_true(grepl(42, checkMatrix(x, min.cols = 43))) }) checkmate/tests/testthat/test_qassert.R0000644000176200001440000001773712763531222020066 0ustar liggesuserscontext("qtest") xb = logical(10); xb[5] = NA xi = integer(10); xi[5] = NA xr = double(10); xr[5] = NA xc = complex(10); xc[5] = NA xl = as.list(1:10); xl[5] = list(NULL) xm = matrix(1:9, 3); xm[2, 3] = NA xd = data.frame(a=1:5, b=1:5); xd$b[3] = NA xf = factor(letters[1:10]); xf[5] = NA xe = new.env(); xe$foo = 1 expect_succ_all = function(x, rules) { xn = deparse(substitute(x)) expect_true(qtest(x, rules), info = sprintf("rules: %s", paste(rules, collapse=",")), label = xn) expect_identical(qassert(x, rules), x, info = sprintf("rules: %s", paste(rules, collapse=",")), label = xn) expect_expectation_successful(qexpect(x, rules), info = sprintf("rules: %s", paste(rules, collapse=",")), label = xn) } expect_fail_all = function(x, rules, pattern = NULL) { xn = deparse(substitute(x)) expect_false(qtest(x, rules), info = sprintf("rules: %s", paste0(rules, collapse=",")), label = xn) expect_error(qassert(x, rules), regex = pattern, info = sprintf("rules: %s", paste0(rules, collapse=",")), label = xn) expect_expectation_failed(qexpect(x, rules), info = sprintf("rules: %s", paste0(rules, collapse=",")), label = xn) } test_that("type and missingness", { expect_succ_all(xb, "b") expect_fail_all(xb, "B") expect_succ_all(xi, "i") expect_fail_all(xi, "I") expect_succ_all(xr, "r") expect_fail_all(xr, "R") expect_succ_all(xc, "c") expect_fail_all(xc, "C") expect_succ_all(xl, "l") expect_fail_all(xl, "L") expect_succ_all(xm, "m") expect_fail_all(xm, "M") expect_succ_all(xd, "d") expect_fail_all(xd, "D") expect_succ_all(xe, "e") expect_succ_all(xf, "f") expect_fail_all(xf, "F") expect_fail_all(xd, "b") expect_fail_all(xd, "i") expect_fail_all(xd, "r") expect_fail_all(xd, "c") expect_fail_all(xd, "l") expect_fail_all(xd, "m") expect_fail_all(xl, "e") expect_fail_all(xm, "r") expect_fail_all(xl, "d") expect_fail_all(xl, "f") expect_fail_all(xl, c("f", "n"), "One of") expect_error(qassert(1, "O"), "Unknown class identifier") }) test_that("integerish", { expect_succ_all(xb, "x") expect_succ_all(xi, "x") expect_succ_all(xi, "x") expect_fail_all(xi, "X") expect_succ_all(xr, "x") expect_fail_all(xr, "X") expect_fail_all(1:3+.0001, "x") expect_fail_all(xd, "x") }) test_that("length", { expect_succ_all(xb, "b+") expect_succ_all(xb, "b10") expect_succ_all(logical(1), "b+") expect_succ_all(logical(1), "b?") expect_succ_all(logical(1), "b1") expect_fail_all(xb, "b?") expect_fail_all(xb, "b5") expect_fail_all(xb, "b>=50") expect_succ_all(xb, "b<=50") expect_succ_all(xe, "e1") expect_fail_all(xe, "e>=2") expect_fail_all(xe, "f+") expect_error(qassert(1, "n9999999999999"), "handle length") expect_error(qassert(1, "n-1"), "negative length") }) test_that("bounds", { xx = 1:3 expect_succ_all(xx, "i+(0,4)") expect_succ_all(xx, "i+(0.9999,3.0001)") expect_succ_all(xx, "i+(0,1e2)") expect_succ_all(1, "n[0, 100]") expect_fail_all(xx, "i+[1,2)") expect_fail_all(xx, "i+[1,2]") expect_fail_all(xx, "i+[1,3)") expect_succ_all(xx, "i+[1,3]") expect_fail_all(xx, "i+(2,3]") expect_fail_all(xx, "i+[2,2]") expect_fail_all(xx, "i+(1,3)") expect_succ_all(xx, "i+[1,3]") expect_succ_all(xx, "i[1,)") expect_succ_all(xx, "i[,3]") expect_succ_all(Inf, "n(1,]") expect_succ_all(-Inf, "n[,1]") expect_succ_all(c(-Inf, 0, Inf), "n[,]") expect_fail_all(Inf, "n(1,)") expect_fail_all(-Inf, "n(,0]") expect_fail_all(c(-Inf, 0, Inf), "n(,]") expect_fail_all(c(-Inf, 0, Inf), "n(,)") xx = letters[1:3] expect_succ_all(xx, "s+[1,]") expect_succ_all(xx, "s+[1,1]") expect_fail_all(xx, "s+[2]") expect_fail_all(NA_character_, "s+[1]") expect_fail_all(NA, "s+[1]") xx = factor(letters[1:3]) expect_succ_all(xx, "f+[1,]") expect_succ_all(xx, "f+[1,1]") expect_fail_all(xx, "f+[2]") expect_fail_all(NA_integer_, "f+[1]") expect_fail_all(NA_character_, "f+[1]") expect_fail_all(NA, "f+[1]") expect_succ_all(1, "n+()") expect_succ_all(1, "n+[]") expect_succ_all(Inf, "n+[]") expect_succ_all(Inf, "n+(]") expect_succ_all(-Inf, "n+[)") expect_fail_all(Inf, "n+()") expect_fail_all(Inf, "n+[)") expect_fail_all(-Inf, "n+(]") expect_error(qassert(iris, "d+[1]"), "Bound checks") }) test_that("non-atomic types", { expect_succ_all(function() 1, "*") expect_fail_all(function() 1, "b") expect_succ_all(function() 1, "*") expect_succ_all(NULL, "0?") expect_fail_all(xi, "0") expect_fail_all(NULL, "0+") expect_succ_all(NULL, "00") expect_fail_all(xe, "b") expect_fail_all(xf, "b") expect_fail_all(as.symbol("x"), "n") expect_fail_all(xd, "a") }) test_that("atomic types", { expect_succ_all(NULL, "a") expect_succ_all(xb, "a+") expect_fail_all(xb, "A+") expect_succ_all(xi, "a+") expect_fail_all(xi, "A+") expect_succ_all(xi, "n+") expect_fail_all(xi, "N+") expect_succ_all(xr, "n+") expect_fail_all(xr, "N+") expect_succ_all(xr, "a+") expect_fail_all(xr, "A+") expect_succ_all(xm, "a+") expect_fail_all(xm, "A+") expect_fail_all(xl, "a+") expect_fail_all(xl, "A+") expect_fail_all(xe, "a+") expect_succ_all(xf, "a+") expect_fail_all(NULL, "v") expect_succ_all(xb, "v+") expect_fail_all(xb, "V+") expect_succ_all(xi, "v+") expect_fail_all(xi, "V+") expect_succ_all(xr, "v+") expect_fail_all(xr, "V+") expect_fail_all(xm, "v+") expect_fail_all(xm, "V+") expect_fail_all(xl, "v+") expect_fail_all(xl, "V+") expect_fail_all(xe, "v+") expect_fail_all(xf, "V+") }) test_that("optional chars", { expect_succ_all(TRUE, "b*") expect_succ_all(TRUE, "b=1") expect_succ_all(TRUE, "b>=0") expect_succ_all(TRUE, "b>0") expect_succ_all(TRUE, "b<2") expect_fail_all(TRUE, "b=2") expect_fail_all(TRUE, "b>=2") expect_fail_all(TRUE, "b>2") expect_fail_all(TRUE, "b<0") }) test_that("malformated pattern", { expect_error(qassert(1, ""), "[Ee]mpty") # expect_warning(expect_error(qassert(1, "ä")), "locale") expect_error(qassert(1, "nn"), "length definition") expect_error(qassert(1, "n="), "length definition") expect_error(qassert(1, "n=="), "length definition") expect_error(qassert(1, "n==="), "length definition") expect_error(qassert(1, "n?1"), "bound definition") expect_error(qassert(1, "n>")) expect_error(qassert(1, "nö")) expect_error(qassert(1, "n\n")) expect_error(qassert(1, "n+a"), "opening") expect_error(qassert(1, "n+["), "bound") expect_error(qassert(1, "n+[1"), "lower") expect_error(qassert(1, "n+[x,]"), "lower") expect_error(qassert(1, "n+[,y]"), "upper") expect_error(qassert(1, "n*("), "bound definition") expect_error(qassert(1, "n*]"), "bound definition") expect_error(qassert(1, "n*(1)xx"), "Additional chars found") expect_error(qassert(1, TRUE), "be a string") expect_error(qassert(1, NA_character_), "not be NA") expect_error(qtest(1, TRUE), "be a string") expect_error(qtest(1, NA_character_), "not be NA") }) test_that("we get some output", { expect_error(qassert(1, "b"), "logical") expect_error(qassert(1, "l"), "list") expect_error(qassert(1:2, "n?"), "length <=") }) test_that("empty vectors", { expect_succ_all(integer(0), "i*") expect_succ_all(integer(0), "i*[0,0]") expect_succ_all(integer(0), "n[0,0]") expect_fail_all(integer(0), "r[0,0]") expect_fail_all(integer(0), "*+") expect_succ_all(TRUE, character(0)) }) test_that("logicals are not numeric", { expect_fail_all(TRUE, "i") expect_fail_all(TRUE, "I") expect_fail_all(TRUE, "n") expect_fail_all(TRUE, "N") }) test_that("data frames are not lists", { expect_fail_all(iris, "l") expect_fail_all(iris, "L") }) test_that("error messages are properly generated", { expect_error(qassert(1, "N22"), "== 22") expect_error(qassert(1:3, "N?"), "<= 1") expect_error(qassert(integer(0), "N+"), ">= 1") expect_error(qassert(1, "N[2,]"), ">= 2") expect_error(qassert(1, "N(2,]"), "> 2") expect_error(qassert(1, "N[,0]"), "<= 0") expect_error(qassert(1, "N[,0)"), "< 0") expect_error(qassert(Inf, "N[)"), "!= Inf") expect_error(qassert(-Inf, "N(]"), "!= -Inf") }) checkmate/tests/testthat/test_checkFactor.R0000644000176200001440000000330512762012005020572 0ustar liggesuserscontext("checkFactor") test_that("checkFactor", { myobj = factor(letters[1:2]) expect_succ_all(Factor, myobj) myobj = letters[1:2] expect_fail_all(Factor, myobj) x = factor(c("a", "b"), levels = c("a", "b")) expect_true(testFactor(x)) expect_false(testFactor(integer(1))) expect_false(testFactor("a")) expect_true(testFactor(factor())) # expect_false(testFactor(integer(0))) expect_false(testFactor(NULL)) expect_true(testFactor(x, levels = rev(levels(x)))) expect_true(testFactor(x, empty.levels.ok = FALSE)) expect_true(testFactor(x, ordered = FALSE)) expect_false(testFactor(x, levels = c("a"))) expect_false(testFactor(x, levels = c("a", "b", "c"))) x = factor(c("a", "b"), levels = c("a", "b", "c"), ordered = TRUE) expect_true(testFactor(x, empty.levels.ok = TRUE)) expect_false(testFactor(x, empty.levels.ok = FALSE)) expect_true(testFactor(x, ordered = TRUE)) expect_false(testFactor(x, ordered = FALSE)) x = factor(c("a", "b"), levels = c("a", "b", "c")) expect_error(assertFactor(1), "factor") expect_error(assertFactor(x, levels = c("a")), "levels") expect_error(assertFactor(x, empty.levels.ok = FALSE), "empty") expect_error(assertFactor(x, ordered = TRUE), "ordered") x = as.ordered(x) expect_error(assertFactor(x, ordered = FALSE), "unordered") x = factor(c("a", "b")) expect_true(testFactor(x, n.levels = 2)) expect_true(testFactor(x, min.levels = 2)) expect_true(testFactor(x, max.levels = 2)) expect_false(testFactor(x, n.levels = 1)) expect_false(testFactor(x, min.levels = 3)) expect_false(testFactor(x, max.levels = 1)) expect_error(testFactor(x, n.levels = NA)) expect_error(assertFactor(x, n.levels = 1), "exactly 1 level") }) checkmate/tests/testthat/test_checkTibble.R0000644000176200001440000000046312762012005020557 0ustar liggesuserscontext("checkTibble") test_that("checkTibble", { skip_if_not_installed("tibble") library(tibble) x = as_tibble(iris) expect_succ_all("Tibble", x) expect_fail_all("Tibble", iris) expect_true(testTibble(x, min.rows = 1, ncols = 5)) expect_false(testTibble(x, min.rows = 1000, ncols = 5)) }) checkmate/tests/testthat/test_checkArray.R0000644000176200001440000000275412762012005020441 0ustar liggesuserscontext("checkArray") test_that("checkArray", { myobj = array(1:2) expect_succ_all(Array, myobj) myobj = 1:2 expect_fail_all(Array, myobj) x = array(dim = c(2, 3)) expect_true(testArray(x)) expect_true(testArray(x, d = 2L)) expect_false(testArray(x, d = 1L)) expect_true(testArray(x, min.d = 0L)) expect_true(testArray(x, min.d = 1L)) expect_true(testArray(x, max.d = 2L)) expect_true(testArray(x, max.d = 3L)) expect_false(testArray(x, min.d = 3L)) expect_false(testArray(x, max.d = 1L)) x[2,2] = NA expect_true(testMatrix(x)) expect_false(testMatrix(x, any.missing = FALSE)) expect_false(testArray(x, any.missing = FALSE)) expect_error(assertArray(iris)) x = array(1:27, dim = c(3, 3, 3)) expect_true(testArray(x, mode = "integer")) expect_true(testArray(x, mode = "numeric")) expect_true(testArray(x, mode = "atomic")) expect_false(testArray(x, mode = "double")) expect_false(testArray(x, mode = "character")) expect_false(testArray(x, mode = "list")) x = array(list(1, 1), dim = c(1, 2)) expect_true(testArray(x)) expect_true(testArray(x, mode = "list")) expect_false(testArray(x, mode = "atomic")) expect_false(testArray(x, mode = "numeric")) expect_error(assertArray(1:3), "array") }) test_that("type guessing works", { x = array(1:4) expect_match(checkCharacter(x), "array") x = array(1:4, dim = c(2, 2)) expect_match(checkCharacter(x), "matrix") x = array(1:9, dim = c(3, 3, 3)) expect_match(checkCharacter(x), "array") }) checkmate/tests/testthat/test_checkInt.R0000644000176200001440000000140112762012005020101 0ustar liggesuserscontext("checkInt") test_that("checkInt", { myobj = 1L expect_succ_all(Int, myobj) myobj = 1.1 expect_fail_all(Int, myobj) expect_false(testInt(integer(0))) expect_false(testInt(NULL)) expect_false(testInt(FALSE)) expect_false(testInt(TRUE)) expect_true(testInt(1L)) expect_true(testInt(1.)) expect_false(testInt(NA)) expect_true(testInt(NA_real_, na.ok = TRUE)) expect_false(testInt(1:2)) expect_false(testInt("")) expect_error(assertInt(2+3i), "integerish") }) test_that("bounds of vectors with only missings are not checked", { expect_true(checkInt(NA, na.ok = TRUE, lower = 1)) expect_true(checkInt(NA_character_, na.ok = TRUE, upper = 10)) expect_fail_all(Int, 0L, lower = 1L) expect_fail_all(Int, 100L, upper = 10L) }) checkmate/tests/testthat/test_assert.R0000644000176200001440000000221212762012005017653 0ustar liggesuserscontext("assert") test_that("assert w/ check*", { x = NULL expect_true(assert(checkNull(x), checkDataFrame(x))) expect_true(assert(checkNull(x))) grepme = iris expect_true(assert(checkNull(grepme), checkDataFrame(grepme))) expect_error(assert(checkNull(grepme), checkNumeric(grepme)), "One of") expect_error(assert(checkNull(grepme), checkNumeric(grepme)), "grepme") x = 1 expect_true(assert(checkNumeric(x), checkCount(x))) expect_true(assert(checkNumeric(x), checkCount(x), combine = "or")) expect_true(assert(checkNumeric(x), checkCount(x), combine = "and")) x = 1.1 expect_true(assert(checkNumeric(x), checkCount(x), combine = "or")) expect_error(assert(checkNumeric(x), checkCount(x), combine = "and")) x = "a" expect_true(assert(checkString(x))) expect_error(assert(checkNumeric(x), checkCount(x), combine = "or")) expect_error(assert(checkNumeric(x), checkCount(x), combine = "and")) }) test_that("bug #69", { sub = subset = 1:150 res = assert(checkIntegerish(subset), checkLogical(subset, len = 150)) expect_true(res) res = assert(checkIntegerish(sub), checkLogical(sub, len = 150)) expect_true(res) }) checkmate/tests/testthat/test_checkClass.R0000644000176200001440000000176712762012005020433 0ustar liggesuserscontext("checkClass") test_that("checkClass", { myobj = 1 expect_succ_all(Class, myobj, "numeric") expect_fail_all(Class, myobj, "integer") expect_true(testClass(NULL, "NULL")) expect_true(testClass(1, "numeric")) expect_true(testClass(1L, "integer")) expect_false(testClass(1, "integer")) foo = 1 class(foo) = c("a", "b") expect_true(testClass(foo, "a")) expect_true(testClass(foo, "b")) expect_false(testClass(foo, "c")) expect_true(testClass(foo, "a", ordered=TRUE)) expect_false(testClass(foo, "b", ordered=TRUE)) expect_true(testClass(foo, c("a", "b"), ordered=TRUE)) expect_false(testClass(foo, c("b", "a"), ordered=TRUE)) foo = 1 class(foo) = c("a", "b") expect_error(assertClass(foo, "c"), "Must have class 'c', but has classes 'a','b'") expect_error(assertClass(foo, "b", ordered=TRUE), "Must have class 'b' in position 1, but has classes 'a','b'") foo = 1 class(foo) = "a" expect_error(assertClass(foo, "c"), "Must have class 'c', but has class 'a'") }) checkmate/tests/testthat/test_checkNamed.R0000644000176200001440000000335412762012005020404 0ustar liggesuserscontext("checkNamed") test_that("checkNamed", { myobj = setNames(1:3, letters[1:3]) expect_succ_all(Named, myobj) myobj = 1:3 expect_fail_all(Named, myobj) expect_true(testNamed(integer(0))) expect_true(testNamed(NULL)) expect_true(testNamed(setNames(integer(0), character(0)))) x = setNames(1:2, c("a", ".a")) expect_true(testNamed(x)) expect_true(testNamed(x, "unique")) expect_true(testNamed(x, "strict")) expect_false(testNamed(1)) expect_false(testNamed(setNames(x, NA_character_))) expect_false(testNamed(setNames(x, NA_integer_))) expect_false(testNamed(setNames(x, ""))) x = setNames(1:2, c("a", "a")) expect_true(testNamed(x)) expect_false(testNamed(x, "unique")) x = setNames(1:2, c("a", "1")) expect_true(testNamed(x)) expect_false(testNamed(x, "strict")) x = setNames(1:2, c("a", "..1")) expect_true(testNamed(x)) expect_false(testNamed(x, "strict")) x = setNames(1, "") expect_error(assertNamed(x), "named") x = setNames(1:2, c("a", "a")) expect_error(assertNamed(x, "unique"), "uniquely") expect_true(testNamed(setNames(1, "x"), type = "strict")) expect_true(testNamed(setNames(1, "..x"), type = "strict")) expect_true(testNamed(setNames(1, "x_1"), type = "strict")) expect_true(testNamed(setNames(1, "x."), type = "strict")) expect_false(testNamed(setNames(1, "1"), type = "strict")) expect_false(testNamed(setNames(1, ".1"), type = "strict")) expect_false(testNamed(setNames(1, "..1"), type = "strict")) expect_false(testNamed(setNames(1, "x "), type = "strict")) expect_false(testNamed(setNames(1, "ä"), type = "strict")) expect_error(assertNamed(x, "unique"), "uniquely") x = setNames(1:2, c("a", "1")) expect_error(assertNamed(x, "strict"), "naming rules") }) checkmate/tests/testthat/test_checkChoice.R0000644000176200001440000000131313006323772020553 0ustar liggesuserscontext("checkChoice") test_that("checkChoice", { myobj = 1 expect_succ_all(Choice, myobj, 1:3) myobj = 0 expect_fail_all(Choice, myobj, 1:3) expect_false(testChoice(character(0), letters)) expect_false(testChoice(NULL, letters)) expect_false(testChoice(1, NULL)) expect_error(testChoice(list(1), as.list(iris)), "atomic") expect_true(testChoice(factor("a"), letters)) expect_true(testChoice(factor("a"), factor(letters))) expect_true(testChoice(1L, 1:10)) expect_false(testChoice("ab", letters)) expect_false(testChoice(NA_integer_, 1:10)) expect_false(testChoice(1:2, 1:10)) expect_error(assertChoice(-1, 1:2), "element of") expect_error(assertChoice(1L, list()), "atomic") }) checkmate/tests/testthat/helper.R0000644000176200001440000000615312766720637016627 0ustar liggesusersexpect_expectation_successful = function(expr, info = NULL, label = NULL) { res = tryCatch(expr, expectation = function(e) e) expect_is(res, "expectation_success", info = info, label = label) } expect_expectation_failed = function(expr, pattern = NULL, info = NULL, label = NULL) { x = tryCatch(expr, expectation = function(e) e) expect_is(x, "expectation_failure", info = info, label = label) } expect_succ_all = function(part, x, ..., cc = as.character(substitute(part)), lc = convertCamelCase(cc)) { xn = deparse(substitute(x)) # check null.ok if it is in formals s = paste0("check", cc) fun = match.fun(s) if ("null.ok" %in% names(formals(fun))) { dots = list(...) dots["x"] = list(NULL) dots$null.ok = TRUE expect_true(do.call(fun, dots)) } s = paste0("check", cc) fun = match.fun(s) expect_true(fun(x, ...), label = s) s = paste0("check_", lc) fun = match.fun(s) expect_true(fun(x, ...), label = s) s = paste0("test", cc) fun = match.fun(s) expect_true(fun(x, ...), info = s, label = xn) s = paste0("test_", lc) fun = match.fun(s) expect_true(fun(x, ...), info = s, label = xn) s = paste0("assert", cc) fun = match.fun(s) expect_identical(fun(x, ...), x, info = s, label = xn) s = paste0("assert_", lc) fun = match.fun(s) expect_identical(fun(x, ...), x, info = s, label = xn) s = paste0("expect_", lc) fun = match.fun(s) expect_expectation_successful(fun(x, ...), info = s, label = xn) invisible(TRUE) } expect_fail_all = function(part, x, ..., cc = as.character(substitute(part)), lc = convertCamelCase(cc)) { xn = deparse(substitute(x)) # check null.ok if it is in formals s = paste0("check", cc) fun = match.fun(s) if ("null.ok" %in% names(formals(fun))) { dots = list(...) dots["x"] = list(NULL) dots$null.ok = FALSE expect_true(grepl("'NULL'", do.call(fun, dots), fixed = TRUE)) } s = paste0("check", cc) fun = match.fun(s) res = fun(x, ...) expect_true(is.character(res) && nzchar(res), info = s, label = xn) s = paste0("test", cc) fun = match.fun(s) expect_false(fun(x, ...), info = s, label = xn) s = paste0("test_", lc) fun = match.fun(s) expect_false(fun(x, ...), info = s, label = xn) s = paste0("assert", cc) fun = match.fun(s) expect_error(fun(x, ..., .var.name = xn), xn, info = s, label = xn) expect_error(fun(x, ...), "'x'", info = s, label = xn) expect_is(tryCatch(fun(x, ...), condition = function(c) c), c("assertion_error", "error", "condition")) s = paste0("assert_", lc) fun = match.fun(s) expect_error(fun(x, ..., .var.name = xn), xn, info = s, label = xn) expect_error(fun(x, ...), "'x'", info = s, label = xn) expect_is(tryCatch(fun(x, ...), condition = function(c) c), c("assertion_error", "error", "condition")) s = paste0("expect_", lc) fun = match.fun(s) expect_expectation_failed(fun(x, ...), pattern = "x", info = s, label = xn) expect_expectation_failed(fun(x, ..., label = xn), pattern = xn, info = s, label = xn) invisible(TRUE) } vlapply = function (x, fun, ..., use.names = TRUE) { vapply(X = x, FUN = fun, ..., FUN.VALUE = NA, USE.NAMES = use.names) } checkmate/tests/testthat/test_asType.R0000644000176200001440000000454112762012005017626 0ustar liggesuserscontext("asType") test_that("asInteger", { xi = 1:5 xd = as.double(1:5) xc = as.complex(1:5) expect_equal(asInteger(xi), xi) expect_equal(asInteger(xd), xi) expect_equal(asInteger(xc), xi) expect_equal(asInteger(NA), NA_integer_) expect_equal(names(asInteger(xi)), names(xi)) expect_equal(names(asInteger(xd)), names(xd)) expect_equal(names(asInteger(xc)), names(xc)) names(xi) = names(xd) = names(xc) = letters[1:5] expect_equal(names(asInteger(xi)), names(xi)) expect_equal(names(asInteger(xd)), names(xd)) expect_equal(names(asInteger(xc)), names(xc)) y = "a" expect_error(asInteger(y), "'y'") expect_error(asInteger(3+1i)) expect_error(asInteger(iris)) expect_error(asInteger(NA, any.missing = FALSE), "missing") }) test_that("asInt", { xi = 1L xd = 1. xc = as.complex(1) expect_equal(names(asInt(xi)), names(xi)) expect_equal(names(asInt(xd)), names(xd)) expect_equal(names(asInt(xc)), names(xc)) names(xi) = names(xd) = names(xc) = "a" expect_equal(names(asInt(xi)), names(xi)) expect_equal(names(asInt(xd)), names(xd)) expect_equal(names(asInt(xc)), names(xc)) expect_error(asInt(letters[1:2]), "integerish") expect_error(asInt(1:2), "length 1") expect_equal(asInt(xi), xi) expect_equal(asInt(xd), xi) expect_equal(asInt(xc), xi) expect_error(asInt(NA), "NA") expect_equal(asInt(NA, na.ok = TRUE), NA_integer_) y = "a" expect_error(asInt(y), "'y'") expect_error(asInt(3+1i)) expect_error(asInt(iris)) expect_error(asInt(xi, lower = 2), ">=") }) test_that("asCount", { xi = 1L xd = 1. xc = as.complex(1) expect_equal(names(asCount(xi)), names(xi)) expect_equal(names(asCount(xd)), names(xd)) expect_equal(names(asCount(xc)), names(xc)) names(xi) = names(xd) = names(xc) = "a" expect_equal(names(asCount(xi)), names(xi)) expect_equal(names(asCount(xd)), names(xd)) expect_equal(names(asCount(xc)), names(xc)) expect_error(asCount(letters[1:2]), "count") expect_error(asCount(1:2), "length 1") expect_equal(asCount(xi), xi) expect_equal(asCount(xd), xi) expect_equal(asCount(xc), xi) expect_error(asCount(NA), "NA") expect_equal(asCount(NA, na.ok = TRUE), NA_integer_) y = "a" expect_error(asCount(y), "'y'") expect_error(asCount(3+1i)) expect_error(asCount(iris)) expect_error(asCount(0, positive = TRUE)) expect_equal(asCount(1, positive = FALSE), 1L) }) checkmate/tests/testthat/test_checkAtomic.R0000644000176200001440000000256212766720671020617 0ustar liggesuserscontext("checkAtomic") li = list( list = list(1, 2), factor = factor("a"), integer = 1:2, NULL = NULL, data.frame = iris ) test_that("checkAtomic", { myobj = 1:2 expect_succ_all(Atomic, myobj) myobj = iris expect_fail_all(Atomic, myobj) expect_true(testAtomic(integer(0))) expect_true(testAtomic(NULL)) expect_true(testAtomic(1)) expect_true(testAtomic(integer(0))) expect_true(testAtomic(factor(1))) expect_true(testAtomic(NA, any.missing = TRUE)) expect_false(testAtomic(NA, any.missing = FALSE)) expect_false(testAtomic(NA, all.missing = FALSE)) expect_true(testAtomic(1, len=1)) expect_false(testAtomic(1, len=0)) expect_true(testAtomic(1, min.len=0)) expect_false(testAtomic(1, min.len=2)) expect_true(testAtomic(1, max.len=1)) expect_false(testAtomic(1, max.len=0)) expect_true(testAtomic(1, unique=TRUE)) expect_false(testAtomic(1, min.len=2)) expect_true(testAtomic(1, max.len=1)) expect_false(testAtomic(1, max.len=0)) expect_true(testAtomic(1, unique=TRUE)) expect_true(testAtomic(c(1,1), unique=FALSE)) expect_false(testAtomic(c(1,1), unique=TRUE)) expect_true(testAtomic(1, names="unnamed")) expect_true(testAtomic(setNames(1, "x"), names="named")) expect_false(testAtomic(1, names="unique")) expect_error(assertAtomic(iris), "atomic") expect_equal(vlapply(li, is.atomic), vlapply(li, testAtomic)) }) checkmate/tests/testthat/test_checkLogical.R0000644000176200001440000000112512762012005020724 0ustar liggesuserscontext("checkLogical") test_that("checkLogical", { myobj = TRUE expect_succ_all(Logical, myobj) myobj = 1 expect_fail_all(Logical, myobj) expect_true(testLogical(logical(0))) expect_false(testLogical(NULL)) expect_true(testLogical(TRUE)) expect_true(testLogical(NA)) expect_true(testLogical(NA_real_)) expect_true(testLogical(FALSE)) expect_false(testLogical(NA, any.missing=FALSE)) expect_false(testLogical(NA, all.missing=FALSE)) expect_false(testLogical(iris)) expect_true(testLogical(c(TRUE, FALSE), min.len = 2)) expect_error(assertLogical(1), "logical") }) checkmate/tests/testthat/test_checkNumber.R0000644000176200001440000000212612762012005020604 0ustar liggesuserscontext("checkNumber") test_that("checkNumber", { myobj = 1 expect_succ_all(Number, myobj) myobj = "a" expect_fail_all(Number, myobj) expect_false(testNumber(integer(0))) expect_false(testNumber(NULL)) expect_false(testNumber(TRUE)) expect_false(testNumber(FALSE)) expect_true(testNumber(1L)) expect_true(testNumber(1.)) expect_false(testNumber(NA)) expect_false(testNumber(NaN)) expect_true(testNumber(NaN, na.ok = TRUE)) expect_true(testNumber(NA_real_, na.ok = TRUE)) expect_false(testNumber(1:2)) expect_false(testNumber("")) expect_true(testNumber(Inf)) expect_true(testNumber(-Inf)) expect_error(assertNumber(Inf, finite = TRUE), "finite") expect_error(assertNumber(-Inf, finite = TRUE), "finite") expect_false(testNumber(TRUE)) expect_error(assertNumber(2+3i), "number") }) test_that("bounds of vectors with only missings are not checked", { expect_true(checkNumber(NA, na.ok = TRUE, lower = 1)) expect_true(checkNumber(NA_character_, na.ok = TRUE, upper = 10)) expect_fail_all(Number, 0, lower = 1) expect_fail_all(Number, 100, upper = 10) }) checkmate/tests/testthat/test_checkAtomicVector.R0000644000176200001440000000337412766720672022005 0ustar liggesuserscontext("checkAtomicVector") test_that("checkAtomicVector", { myobj = 1:2 expect_succ_all(AtomicVector, myobj) myobj = NULL expect_fail_all(AtomicVector, myobj) expect_true(testAtomicVector(integer(0))) expect_false(testAtomicVector(NULL)) expect_true(testAtomicVector(1)) expect_true(testAtomicVector(integer(0))) expect_true(testAtomicVector(factor(1))) expect_true(testAtomicVector(NA, any.missing = TRUE)) expect_false(testAtomicVector(NA, any.missing = FALSE)) expect_false(testAtomicVector(NA, all.missing = FALSE)) expect_true(testAtomicVector(1, len=1)) expect_false(testAtomicVector(1, len=0)) expect_true(testAtomicVector(1, min.len=0)) expect_false(testAtomicVector(1, min.len=2)) expect_true(testAtomicVector(1, max.len=1)) expect_false(testAtomicVector(1, max.len=0)) expect_true(testAtomicVector(1, unique=TRUE)) expect_false(testAtomicVector(1, min.len=2)) expect_true(testAtomicVector(1, max.len=1)) expect_false(testAtomicVector(1, max.len=0)) expect_true(testAtomicVector(1, unique=TRUE)) expect_true(testAtomicVector(c(1,1), unique=FALSE)) expect_false(testAtomicVector(c(1,1), unique=TRUE)) expect_true(testAtomicVector(1, names="unnamed")) expect_true(testAtomicVector(setNames(1, "x"), names="named")) expect_false(testAtomicVector(1, names="unique")) expect_error(assertAtomicVector(iris), "atomic") li = list(list = list(1, 2), factor = factor("a"), integer = 1:2, NULL = NULL, data.frame = iris, matrix = matrix(1:9)) expected = setNames(c(FALSE, TRUE, TRUE, FALSE, FALSE, FALSE), names(li)) expect_equal(expected, vlapply(li, testAtomicVector)) }) test_that("type guessing works (#48)", { x = structure(list(1:4, letters[1:3]), dim = c(2, 1)) expect_match(checkAtomic(x), "list") }) checkmate/tests/testthat/test_anyMissing.R0000644000176200001440000000457512766720672020535 0ustar liggesuserscontext("anyMissing") xb = logical(10) xi = integer(10) xd = double(10) xc = complex(10) xs = letters[1:10] xl = as.list(1:10) xm = matrix(1:9, 3) xf = data.frame(a=1:5, b=1:5) test_that("anyMissing", { expect_false(anyMissing(integer(0))) expect_false(anyMissing(xb)) expect_false(anyMissing(xi)) expect_false(anyMissing(xd)) expect_false(anyMissing(xc)) expect_false(anyMissing(xs)) expect_false(anyMissing(xl)) expect_false(anyMissing(xm)) expect_false(anyMissing(xf)) xb[5] = xi[5] = xd[5] = xc[5] = xs[5] = xm[2, 2] = xf$b[3] = NA xl[5] = list(NULL) expect_true(anyMissing(xb)) expect_true(anyMissing(xi)) expect_true(anyMissing(xd)) expect_true(anyMissing(xc)) expect_true(anyMissing(xs)) expect_true(anyMissing(xl)) expect_true(anyMissing(xm)) expect_true(anyMissing(xf)) expect_false(anyMissing(as.raw(1))) expect_false(anyMissing(NULL)) expect_error(anyMissing(as.symbol("a")), "supported") }) test_that("allMissing", { expect_true(allMissing(integer(0))) expect_false(allMissing(xb)) expect_false(allMissing(xi)) expect_false(allMissing(xd)) expect_false(allMissing(xc)) expect_false(allMissing(xs)) expect_false(allMissing(xl)) expect_false(allMissing(xm)) expect_false(allMissing(xf)) xb[5] = xi[5] = xd[5] = xc[5] = xm[2, 2] = xf$b[3] = NA xl[5] = list(NULL) expect_false(allMissing(xb)) expect_false(allMissing(xi)) expect_false(allMissing(xd)) expect_false(allMissing(xc)) expect_false(allMissing(xs)) expect_false(allMissing(xl)) expect_false(allMissing(xm)) expect_false(allMissing(xf)) xb[] = xi[] = xd[] = xc[] = xm[] = xs = NA xl = list(NULL, NULL) xf$a = xf$b = NA expect_true(allMissing(xb)) expect_true(allMissing(xi)) expect_true(allMissing(xd)) expect_true(allMissing(xc)) expect_true(allMissing(xs)) expect_true(allMissing(xl)) expect_true(allMissing(xm)) expect_true(allMissing(xf)) expect_false(allMissing(as.raw(1))) expect_false(allMissing(NULL)) expect_error(allMissing(as.symbol("a")), "supported") }) test_that("anyMissing and allMissing work correctly with data.frames", { df = data.frame(a = 1:2, b = 2:1) expect_false(anyMissing(df)) expect_false(allMissing(df)) df$b[1] = NA expect_true(anyMissing(df)) expect_false(allMissing(df)) df$b[2] = NA expect_true(anyMissing(df)) expect_true(allMissing(df)) expect_false(all(vlapply(df, allMissing))) }) checkmate/tests/testthat/test_checkDate.R0000644000176200001440000000203112762012005020224 0ustar liggesuserscontext("checkDate") test_that("checkDate", { x = Sys.Date() expect_succ_all(Date, x) expect_fail_all(Date, 1) expect_true(testDate(x, lower = 1)) expect_true(testDate(x, upper = as.integer(x + 2))) expect_error(assertDate(x, lower = x + 2), ">=") expect_error(assertDate(x, upper = x - 2), "<=") expect_true(testDate(x, upper = x + 2)) expect_false(testDate(x, upper = x - 2)) expect_true(testDate(x, lower = x - 2)) expect_false(testDate(x, lower = x + 2)) expect_error(assertDate(x, lower = 1:2), "single") expect_error(assertDate(x, lower = NA), "single") expect_error(assertDate(x, lower = integer(0)), "single") expect_error(assertDate(x, upper = 1:2), "single") expect_error(assertDate(x, upper = NA), "single") expect_error(assertDate(x, upper = integer(0)), "single") x = as.Date(NA) expect_error(assertDate(x, any.missing = FALSE), "missing") x = rep(Sys.Date(), 2) expect_error(assertDate(x, unique = TRUE), "duplicated") expect_error(assertDate(letters, unique = TRUE), "character") }) checkmate/tests/testthat/test_checkFlag.R0000644000176200001440000000073012762012005020224 0ustar liggesuserscontext("checkFlag") test_that("checkFlag", { myobj = TRUE expect_succ_all(Flag, myobj) myobj = NA expect_fail_all(Flag, myobj) expect_false(testFlag(logical(0))) expect_false(testFlag(NULL)) expect_true(testFlag(TRUE)) expect_true(testFlag(FALSE)) expect_false(testFlag(NA)) expect_true(testFlag(NA, na.ok = TRUE)) expect_true(testFlag(NA_character_, na.ok = TRUE)) expect_false(testFlag(iris)) expect_error(assertFlag(1), "logical flag") }) checkmate/tests/testthat/test_anyInfinite.R0000644000176200001440000000141112762012005020627 0ustar liggesuserscontext("anyInfinite") test_that("anyInfinite", { xb = logical(10) xi = integer(10) xd = double(10) xc = complex(10) xl = as.list(1:10) xm = matrix(1:9, 3) xf = data.frame(a=1:5, b=1:5) expect_false(anyInfinite(NULL)) expect_false(anyInfinite(mean)) expect_false(anyInfinite(double(0))) expect_false(anyInfinite(xb)) expect_false(anyInfinite(xi)) expect_false(anyInfinite(xd)) expect_false(anyInfinite(xc)) expect_false(anyInfinite(xl)) expect_false(anyInfinite(xm)) expect_false(anyInfinite(xf)) xd[5] = xc[5] = xf$b[3] = Inf xl[5] = -Inf expect_true(anyInfinite(xd)) expect_true(anyInfinite(xc)) expect_true(anyInfinite(xl)) expect_true(anyInfinite(xf)) x = list(1, list(1, list(1, Inf))) expect_true(anyInfinite(x)) }) checkmate/tests/testthat/test_guessType.R0000644000176200001440000000262312762012005020350 0ustar liggesuserscontext("guessType") test_that("guessType", { xb = logical(10) xi = integer(10) xd = double(10) xc = complex(10) xs = letters[1:10] xl = as.list(1:10) xm = matrix(1:9, 3) xa = array(1:3) xf = data.frame(a=1:5, b=1:5) xx = 1; class(xx) = "Foo" xxx = 1; class(xxx) = c("Foo", "Bar") expect_equal(guessType(xb), "logical") expect_equal(guessType(xi), "integer") expect_equal(guessType(xd), "double") expect_equal(guessType(xc), "complex") expect_equal(guessType(xs), "character") expect_equal(guessType(xl), "list") expect_equal(guessType(xm), "matrix") expect_equal(guessType(xa), "array") expect_equal(guessType(xf), "data.frame") expect_equal(guessType(xx), "Foo") expect_equal(guessType(xxx), "Foo/Bar") expect_true(grepl("NULL'$", checkLogical(NULL))) expect_true(grepl("logical'$", checkInteger(xb))) expect_true(grepl("integer'$", checkLogical(xi))) expect_true(grepl("double'$", checkLogical(xd))) expect_true(grepl("complex'$", checkLogical(xc))) expect_true(grepl("character'$", checkLogical(xs))) expect_true(grepl("factor'$", checkLogical(factor(xs)))) expect_true(grepl("list'$", checkLogical(xl))) expect_true(grepl("matrix'$", checkLogical(xm))) expect_true(grepl("array'$", checkLogical(xa))) expect_true(grepl("frame'$", checkLogical(xf))) expect_true(grepl("Foo'$", checkLogical(xx))) expect_true(grepl("Foo/Bar'$", checkLogical(xxx))) }) checkmate/tests/testthat/test_checkSetEqual.R0000644000176200001440000000270213006324044021100 0ustar liggesuserscontext("checkSetEqual") test_that("checkSetEqual", { myobj = letters[3:1] expect_succ_all(SetEqual, myobj, letters[1:3]) expect_fail_all(SetEqual, myobj, letters[1:3], ordered = TRUE) myobj = letters[1:2] expect_fail_all(String, myobj, letters[1:3]) expect_true(testSetEqual(character(0), character(0))) expect_true(testSetEqual(character(0), character(0), ordered = TRUE)) expect_false(testSetEqual(character(0), letters)) expect_false(testSetEqual(letters, character(0))) expect_false(testSetEqual(NULL, letters)) expect_false(testSetEqual(NULL, letters, ordered = TRUE)) expect_false(testSetEqual(factor("a"), letters)) expect_true(testSetEqual(factor(letters), factor(letters))) expect_true(testSetEqual(letters, factor(letters))) expect_true(testSetEqual(1L, 1L)) expect_true(testSetEqual(1, 1L)) expect_true(testSetEqual(3:4, 3:4)) expect_true(testSetEqual(NA_integer_, NA_integer_)) expect_true(testSetEqual(1:2, 1:2, ordered = TRUE)) expect_false(testSetEqual(1:2, 2:1, ordered = TRUE)) expect_true(testSetEqual(NA, NA, ordered = TRUE)) expect_false(testSetEqual(NA_integer_, 1L, ordered = TRUE)) expect_false(testSetEqual(1L, NA_integer_, ordered = TRUE)) expect_false(testSetEqual(c(NA_integer_, 2L), 1:2, ordered = TRUE)) expect_true(testSetEqual(c(NA_integer_, 2L), c(NA_real_, 2), ordered = TRUE)) expect_error(assertSetEqual(1, 1:2), "equal to") expect_error(assertSetEqual(1L, list()), "atomic") }) checkmate/tests/testthat/test_checkVector.R0000644000176200001440000000461212766720672020644 0ustar liggesuserscontext("checkVector") li = list( list = list(1, 2), factor = factor("a"), integer = 1:2, NULL = NULL, data.frame = iris ) test_that("checkVector", { myobj = 1:3 expect_succ_all(Vector, myobj) myobj = NULL expect_fail_all(Vector, myobj) expect_true(testVector(integer(0))) expect_false(testVector(NULL)) expect_true(testVector(1)) expect_true(testVector(integer(0))) expect_true(testVector(factor(1), strict = FALSE)) expect_false(testVector(factor(1), strict = TRUE)) expect_true(testVector(NA, any.missing = TRUE)) expect_false(testVector(NA, any.missing = FALSE)) expect_false(testVector(NA, all.missing = FALSE)) expect_true(testVector(1, len=1)) expect_false(testVector(1, len=0)) expect_true(testVector(1, min.len=0)) expect_false(testVector(1, min.len=2)) expect_true(testVector(1, max.len=1)) expect_false(testVector(1, max.len=0)) expect_true(testVector(1, unique=TRUE)) expect_false(testVector(1, min.len=2)) expect_true(testVector(1, max.len=1)) expect_false(testVector(1, max.len=0)) expect_true(testVector(1, unique=TRUE)) expect_true(testVector(c(1,1), unique=FALSE)) expect_false(testVector(c(1,1), unique=TRUE)) expect_true(testVector(1, names="unnamed")) expect_true(testVector(setNames(1, "x"), names="named")) expect_false(testVector(1, names="unique")) expect_equal(vlapply(li, is.vector), vlapply(li, testVector, strict = TRUE)) expected = setNames(c(TRUE, TRUE, TRUE, FALSE, TRUE), c("list", "factor", "integer", "NULL", "data.frame")) expect_equal(expected, vlapply(li, testVector, strict = FALSE)) expect_error(assertVector(iris, strict = TRUE), "vector") }) test_that("arguments any.missing and all.missing are checked", { x = 1 expect_error(checkVector(x, any.missing = 1), "flag") expect_error(checkVector(x, any.missing = NA), "missing") expect_error(checkVector(x, all.missing = 1), "flag") expect_error(checkVector(x, all.missing = NA), "missing") }) test_that("length is correctly reported", { x = 1:42 expect_true(grepl(42, checkVector(x, len = 1), fixed = TRUE)) expect_true(grepl(42, checkVector(x, min.len = 43), fixed = TRUE)) expect_true(grepl(42, checkVector(x, max.len = 1), fixed = TRUE)) expect_true(grepl(43, checkVector(x, len = 43), fixed = TRUE)) expect_true(grepl(43, checkVector(x, min.len = 43), fixed = TRUE)) expect_true(grepl(41, checkVector(x, max.len = 41), fixed = TRUE)) }) checkmate/tests/testthat/test_checkIntegerish.R0000644000176200001440000000352113006323271021457 0ustar liggesuserscontext("checkIntegerish") test_that("checkIntegerish", { myobj = 1 expect_succ_all(Integerish, myobj) myobj = 3.3 expect_fail_all(Integerish, myobj) x = 1 - 0.9 -.1 expect_true(testIntegerish(integer(0))) expect_false(testIntegerish(NULL)) expect_false(testIntegerish(TRUE)) expect_false(testIntegerish(FALSE)) expect_true(testIntegerish(1L)) expect_true(testIntegerish(c(-1, 0, 1))) expect_true(testIntegerish(1.)) expect_true(testIntegerish(x)) expect_true(testIntegerish(NA)) expect_true(testIntegerish(NaN)) expect_true(testIntegerish(c(1L, NA))) expect_true(testIntegerish(c(1, NA))) expect_true(testIntegerish(c(1, NaN))) expect_false(testIntegerish(1:2 + 0.0001)) expect_false(testIntegerish(-Inf)) expect_false(testIntegerish(Inf)) expect_true(testIntegerish(3+0i)) expect_false(testIntegerish(3-1i)) expect_true(testIntegerish(as.complex(NA))) expect_false(testIntegerish(3+2i)) expect_false(testIntegerish(list())) max = as.double(.Machine$integer.max) min = as.double(-.Machine$integer.max) expect_true(testIntegerish(min)) expect_true(testIntegerish(max)) expect_false(testIntegerish(min-1)) expect_false(testIntegerish(max+1)) expect_false(testIntegerish(min-.1)) expect_false(testIntegerish(max+.1)) expect_false(testIntegerish(NA, any.missing = FALSE)) expect_false(testIntegerish(NA, all.missing = FALSE)) expect_error(assertIntegerish(x, tol=0), "integerish") }) test_that("bounds of vectors with only missings are not checked", { expect_true(checkInteger(NA, lower = 1)) expect_true(checkInteger(NA_character_, upper = 10)) expect_fail_all(Integerish, 0, lower = 1L) expect_fail_all(Integerish, 100, upper = 10L) }) test_that("isIntegerish internal function", { expect_true(isIntegerish(1)) expect_true(isIntegerish(1.)) expect_false(isIntegerish(1.1)) }) checkmate/tests/testthat/test_checkDataFrame.R0000644000176200001440000000657712762012005021216 0ustar liggesuserscontext("checkDataFrame") test_that("checkDataFrame", { myobj = iris expect_succ_all(DataFrame, myobj) myobj = TRUE expect_fail_all(DataFrame, myobj) expect_true(testDataFrame(data.frame())) expect_false(testDataFrame(NULL)) expect_true(testDataFrame(data.frame(1))) expect_true(testDataFrame(iris)) expect_false(testDataFrame(list(1))) x = iris expect_true(testDataFrame(x, types = c("numeric", "factor"))) expect_false(testDataFrame(x, types = c("integer", "factor"))) expect_false(testDataFrame(x, types = c("numeric", "character"))) expect_true(testDataFrame(data.frame(), types = "NULL")) expect_true(testDataFrame(data.frame(), types = "numeric")) expect_error(assertDataFrame(1), "data.frame") expect_error(assertDataFrame(x, types = "numeric"), "types: numeric") # check nrow and ncol constraints expect_true(testDataFrame(x, nrows = 150L, ncols = 5L)) expect_false(testDataFrame(x, nrows = 150L, ncols = 7L)) expect_true(testDataFrame(x, min.rows = 2L, min.cols = 4L)) expect_false(testDataFrame(x, min.rows = 151L, min.cols = 4L)) expect_false(testDataFrame(x, min.rows = 1L, min.cols = 6L)) }) test_that("checkDataFrame name checking works", { df = data.frame(x = 1:2, y = 1:2) names(df) = c("x", "x") expect_identical(assertDataFrame(df), df) expect_error(assertDataFrame(df, col.names = "unnamed"), "unnamed") names(df) = c("x", "") expect_error(assertDataFrame(df, col.names = "named"), "named") names(df) = c("x", "x") expect_identical(assertDataFrame(df, col.names = "named"), df) expect_error(assertDataFrame(df, col.names = "unique"), "uniquely") expect_error(assertDataFrame(df, col.names = "strict"), "uniquely") expect_error(assertDataFrame(df, col.names = "foo"), "unnamed") names(df) = c("x", "1") expect_identical(assertDataFrame(df, col.names = "named"), df) expect_identical(assertDataFrame(df, col.names = "unique"), df) expect_error(assertDataFrame(df, col.names = "strict"), "naming rules") rownames(df) = letters[1:2] expect_succ_all(DataFrame, df, row.names = "strict") expect_succ_all(DataFrame, df, row.names = "unique") expect_succ_all(DataFrame, df, row.names = "named") expect_fail_all(DataFrame, df, row.names = "unnamed") rownames(df) = NULL expect_fail_all(DataFrame, df, row.names = "unnamed") # no names defaults to as.character(seq_row(x)) expect_succ_all(DataFrame, df, row.names = "named") expect_succ_all(DataFrame, df, row.names = "unique") expect_fail_all(DataFrame, df, row.names = "strict") }) test_that("dimension checks work for empty frames", { x = iris[, -c(1:5)] expect_true(testDataFrame(x, min.rows = 5)) expect_true(testDataFrame(x, nrows = 150)) expect_false(testDataFrame(x, min.rows = 151)) expect_false(testDataFrame(x, nrows = 1)) x = iris[-c(1:150), ] expect_true(testDataFrame(x, min.cols = 1)) expect_true(testDataFrame(x, ncols = 5)) expect_false(testDataFrame(x, min.cols = 6)) expect_false(testDataFrame(x, ncols = 1)) }) test_that("missing values are detected", { x = data.frame(a = 1:2, b = c(1, 2)) expect_true(testDataFrame(x, any.missing = FALSE)) expect_true(testDataFrame(x, all.missing = FALSE)) x$b[1] = NA expect_false(testDataFrame(x, any.missing = FALSE)) expect_true(testDataFrame(x, all.missing = FALSE)) x$b[2] = NA expect_false(testDataFrame(x, any.missing = FALSE)) expect_false(testDataFrame(x, all.missing = FALSE)) }) checkmate/tests/testthat/test_checkFunction.R0000644000176200001440000000317612762012005021147 0ustar liggesuserscontext("checkFunction") test_that("checkFunction", { myobj = mean expect_succ_all(Function, myobj) myobj = TRUE expect_fail_all(Function, myobj) myfun = function(x, y, ...) x + y expect_false(testFunction(NULL)) expect_true(testFunction(identity)) expect_true(testFunction(myfun)) expect_false(testFunction("myfun")) expect_false(testFunction("myfun")) expect_true(testFunction(myfun, args = "x")) expect_true(testFunction(myfun, args = "...")) expect_true(testFunction(myfun, args = "x", ordered=TRUE)) expect_true(testFunction(myfun, args = "y")) expect_true(testFunction(myfun, args = c("x", "y"))) expect_true(testFunction(myfun, args = c("x", "y", "..."))) expect_true(testFunction(myfun, args = c("y", "x"))) expect_true(testFunction(myfun, args = c("x", "y"), ordered=TRUE)) expect_false(testFunction(myfun, args = "z")) expect_false(testFunction(myfun, args = c("y"), ordered=TRUE)) expect_false(testFunction(myfun, args = c("y", "x"), ordered=TRUE)) expect_true(testFunction(myfun, nargs = 2)) expect_true(testFunction(myfun, args = "x", nargs = 2)) expect_true(testFunction(function() 1, nargs = 0)) expect_true(testFunction(function(...) 1, nargs = 0)) expect_false(testFunction(function(...) 1, nargs = 1)) expect_error(assertFunction(fff), "not found") expect_error(assertFunction(myfun, "z"), "formal arguments") expect_error(assertFunction(myfun, "y", ordered=TRUE), "first formal arguments") expect_false(testFunction(function(x) x^2, args = character(0))) expect_true(testFunction(function() x^2, args = character(0))) expect_error(assertFunction(letters), "character") }) checkmate/tests/testthat/test_checkList.R0000644000176200001440000000200112762037177020300 0ustar liggesuserscontext("checkList") test_that("checkList", { myobj = list(1, 2, 3) expect_succ_all(List, myobj) myobj = TRUE expect_fail_all(List, myobj) expect_true(testList(list())) expect_false(testList(NULL)) expect_true(testList(list(1))) expect_false(testList(iris)) x = as.list(iris) expect_true(testList(x, types = c("numeric", "factor"))) expect_false(testList(x, types = c("integer", "factor"))) expect_false(testList(x, types = c("numeric", "character"))) expect_true(testList(x, types = c("vector", "factor"))) expect_true(testList(list(NULL), types = "NULL")) expect_true(testList(list(), types = "numeric")) expect_false(testList(list(TRUE), types = "numeric")) expect_error(assertList(x, types = "numeric"), "types: numeric") expect_error(assertList(x, len = 33), "Must have length 33") expect_true(testList(list(), names = "named")) x = 1:3 class(x) = "foo" x = list(x, 1:3) expect_true(testList(x, types = c("foo", "integerish"))) expect_error(assertList(1), "list") }) checkmate/tests/testthat/test_checkEnvironment.R0000644000176200001440000000127112762012005021660 0ustar liggesuserscontext("checkEnvironment") test_that("checkEnvironment", { myobj = new.env() expect_succ_all(Environment, myobj) myobj = list() expect_fail_all(Environment, myobj) ee = new.env(parent = emptyenv()) ee$yyy = 1 ee$zzz = 1 expect_false(testEnvironment(NULL)) expect_false(testEnvironment(list())) expect_true(testEnvironment(ee)) expect_false(testEnvironment(ee, contains = "xxx")) expect_true(testEnvironment(ee, contains = "yyy")) expect_true(testEnvironment(ee, contains = c("yyy", "zzz"))) expect_error(assertEnvironment(list()), "environment") expect_error(assertEnvironment(ee, "xxx"), "with name") expect_error(assertEnvironment(letters), "character") }) checkmate/tests/testthat/test_checkOS.R0000644000176200001440000000126313004362747017711 0ustar liggesuserscontext("checkOS") test_that("checkOS", { expect_succ_all(OS, c("linux", "mac", "windows", "solaris")) }) test_that("checkOS linux", { skip_on_os("windows") skip_on_os("solaris") skip_on_os("mac") expect_succ_all(OS, "linux", lc = "os") expect_string(checkOS("windows"), fixed = "windows") }) test_that("checkOS mac", { skip_on_os("windows") skip_on_os("solaris") skip_on_os("linux") expect_succ_all(OS, "mac", lc = "os") expect_string(checkOS("windows"), fixed = "windows") }) test_that("checkOS win", { skip_on_os("mac") skip_on_os("solaris") skip_on_os("linux") expect_succ_all(OS, "windows", lc = "os") expect_string(checkOS("mac"), fixed = "mac") }) checkmate/tests/testthat/test_deparse.R0000644000176200001440000000034212762012005017777 0ustar liggesuserscontext("deparse") test_that("deparse", { f = function(num, na.ok) { assertNumber(num) qassert(na.ok, "B1") } expect_true(f(1, TRUE)) expect_error(f(NULL, TRUE), "num") expect_error(f(1, NULL), "na.ok") }) checkmate/tests/test-all.R0000755000176200001440000000005212762012005015203 0ustar liggesuserslibrary(testthat) test_check("checkmate") checkmate/src/0000755000176200001440000000000013006331417012763 5ustar liggesuserscheckmate/src/which_first.c0000644000176200001440000000270113006331417015440 0ustar liggesusers#include "which_first.h" static inline SEXP named_return(R_len_t ind, SEXP names) { if (isNull(names)) return ScalarInteger(ind + 1); SEXP res; PROTECT(res = ScalarInteger(ind + 1)); setAttrib(res, R_NamesSymbol, ScalarString(STRING_ELT(names, ind))); UNPROTECT(1); return res; } SEXP c_which_first(SEXP x, SEXP use_names) { if (!isLogical(x)) error("Argument 'x' must be logical"); if (!isLogical(use_names) || length(use_names) != 1) error("Argument 'use.names' must be a flag"); const R_len_t n = length(x); int *xp = LOGICAL(x); for (R_len_t i = 0; i < n; i++) { if (xp[i] != NA_LOGICAL && xp[i]) { if (LOGICAL(use_names)[0]) return named_return(i, getAttrib(x, R_NamesSymbol)); else return ScalarInteger(i+1); } } return allocVector(INTSXP, 0); } SEXP c_which_last(SEXP x, SEXP use_names) { if (!isLogical(x)) error("Argument 'x' must be logical"); if (!isLogical(use_names) || length(use_names) != 1) error("Argument 'use.names' must be a flag"); int *xp = LOGICAL(x); for (R_len_t i = length(x) - 1; i >= 0; i--) { if (xp[i] != NA_LOGICAL && xp[i]) { if (LOGICAL(use_names)[0]) return named_return(i, getAttrib(x, R_NamesSymbol)); else return ScalarInteger(i+1); } } return allocVector(INTSXP, 0); } checkmate/src/any_infinite.h0000644000176200001440000000030413006331417015605 0ustar liggesusers#ifndef CHECKMATE_ANY_INFINITE_H_ #define CHECKMATE_ANY_INFINITE_H_ #define USE_RINTERNALS #include #include SEXP c_any_infinite(SEXP); Rboolean any_infinite(SEXP); #endif checkmate/src/helper.h0000644000176200001440000000064613006331417014421 0ustar liggesusers#ifndef CHECKMATE_HELPER_H_ #define CHECKMATE_HELPER_H_ #define USE_RINTERNALS #include #include Rboolean isStrictlyNumeric(SEXP); Rboolean isAtomicVector(SEXP); Rboolean isRList(SEXP); R_len_t get_ncols(SEXP); R_len_t get_nrows(SEXP); double asNumber(SEXP, const char *); const char * asString(SEXP, const char *); R_xlen_t asCount(SEXP, const char *); Rboolean asFlag(SEXP, const char *); #endif checkmate/src/guess_type.h0000644000176200001440000000030013006331417015314 0ustar liggesusers#ifndef CHECKMATE_GUESS_TYPE_H_ #define CHECKMATE_GUESS_TYPE_H_ #define USE_RINTERNALS #include #include const char * guess_type(SEXP); SEXP c_guess_type(SEXP); #endif checkmate/src/helper.c0000644000176200001440000000501413006331417014406 0ustar liggesusers#include "helper.h" #include "any_missing.h" #include "is_integerish.h" Rboolean isStrictlyNumeric(SEXP x) { switch(TYPEOF(x)) { case REALSXP: return TRUE; case INTSXP: return !inherits(x, "factor"); } return FALSE; } Rboolean isAtomicVector(SEXP x) { if (!isVectorAtomic(x)) return FALSE; return isNull(getAttrib(x, R_DimSymbol)); } /* Checks for a regular list, i.e. not a data frame, not NULL */ Rboolean isRList(SEXP x) { if (TYPEOF(x) == VECSXP) { SEXP cl = getAttrib(x, R_ClassSymbol); const R_len_t n = length(cl); for (R_len_t i = 0; i < n; i++) { if (strcmp(CHAR(STRING_ELT(cl, i)), "data.frame") == 0) return FALSE; } return TRUE; } return FALSE; } /* ncols and nrows is bugged for data frames: * (a) data.frames are treated like lists and thus you get length() back * (b) reports wrong dimension for zero-column data frames * Here are our own wrappers * */ R_len_t get_nrows(SEXP x) { if (isFrame(x)) return length(getAttrib(x, R_RowNamesSymbol)); SEXP dim = getAttrib(x, R_DimSymbol); return (dim == R_NilValue) ? length(x) : INTEGER(dim)[0]; } R_len_t get_ncols(SEXP x) { if (isFrame(x)) return length(x); SEXP dim = getAttrib(x, R_DimSymbol); return (length(dim) >= 2) ? INTEGER(dim)[1] : 1; } double asNumber(SEXP x, const char *vname) { if (!isNumeric(x) || xlength(x) != 1) error("Argument '%s' must be a number", vname); double xd = asReal(x); if (ISNAN(xd)) error("Argument '%s' may not be missing", vname); return xd; } const char * asString(SEXP x, const char *vname) { if (!isString(x) || xlength(x) != 1) error("Argument '%s' must be a string", vname); if (any_missing_string(x)) error("Argument '%s' may not be missing", vname); return CHAR(STRING_ELT(x, 0)); } R_xlen_t asCount(SEXP x, const char *vname) { if (!isIntegerish(x, INTEGERISH_DEFAULT_TOL, FALSE) || xlength(x) != 1) error("Argument '%s' must be a count", vname); int xi = asInteger(x); if (xi == NA_INTEGER) error("Argument '%s' may not be missing", vname); if (xi < 0) error("Argument '%s' must be >= 0", vname); return xi; } Rboolean asFlag(SEXP x, const char *vname) { if (!isLogical(x) || xlength(x) != 1) error("Argument '%s' must be a flag", vname); Rboolean xb = LOGICAL(x)[0]; if (xb == NA_LOGICAL) error("Argument '%s' may not be missing", vname); return xb; } checkmate/src/is_integerish.h0000644000176200001440000000041713006331417015772 0ustar liggesusers#ifndef CHECKMATE_IS_INTEGERISH_H_ #define CHECKMATE_IS_INTEGERISH_H_ #define USE_RINTERNALS #include #include #define INTEGERISH_DEFAULT_TOL sqrt(DOUBLE_EPS) Rboolean isIntegerish(SEXP, double, Rboolean); SEXP c_is_integerish(SEXP, SEXP); #endif checkmate/src/any_nan.c0000644000176200001440000000175213006331417014557 0ustar liggesusers#include "any_nan.h" static Rboolean any_nan_double(SEXP x) { const double * xp = REAL(x); const double * const xe = xp + xlength(x); for (; xp != xe; xp++) { if (R_IsNaN(*xp)) return TRUE; } return FALSE; } static Rboolean any_nan_complex(SEXP x) { const Rcomplex * xp = COMPLEX(x); const Rcomplex * const xe = xp + xlength(x); for (; xp != xe; xp++) { if (R_IsNaN((*xp).r) || R_IsNaN((*xp).i)) return TRUE; } return FALSE; } static Rboolean any_nan_list(SEXP x) { const R_xlen_t nx = xlength(x); for (R_xlen_t i = 0; i < nx; i++) { if (any_nan(VECTOR_ELT(x, i))) return TRUE; } return FALSE; } Rboolean any_nan(SEXP x) { switch(TYPEOF(x)) { case REALSXP: return any_nan_double(x); case CPLXSXP: return any_nan_complex(x); case VECSXP: return any_nan_list(x); } return FALSE; } SEXP c_any_nan(SEXP x) { return ScalarLogical(any_nan(x)); } checkmate/src/any_infinite.c0000644000176200001440000000216713006331417015611 0ustar liggesusers#include "any_infinite.h" static Rboolean any_infinite_double(SEXP x) { const double * xp = REAL(x); const double * const xe = xp + xlength(x); for (; xp != xe; xp++) { if (*xp == R_PosInf || *xp == R_NegInf) return TRUE; } return FALSE; } static Rboolean any_infinite_complex(SEXP x) { const Rcomplex * xp = COMPLEX(x); const Rcomplex * const xe = xp + xlength(x); for (; xp != xe; xp++) { if ((*xp).r == R_PosInf || (*xp).i == R_PosInf || (*xp).r == R_NegInf || (*xp).i == R_NegInf) return TRUE; } return FALSE; } static Rboolean any_infinite_list(SEXP x) { const R_xlen_t nx = xlength(x); for (R_xlen_t i = 0; i < nx; i++) { if (any_infinite(VECTOR_ELT(x, i))) return TRUE; } return FALSE; } Rboolean any_infinite(SEXP x) { switch(TYPEOF(x)) { case REALSXP: return any_infinite_double(x); case CPLXSXP: return any_infinite_complex(x); case VECSXP: return any_infinite_list(x); } return FALSE; } SEXP c_any_infinite(SEXP x) { return ScalarLogical(any_infinite(x)); } checkmate/src/all_nchar.h0000644000176200001440000000025213006331417015056 0ustar liggesusers#ifndef CHECKMATE_ALL_NCHAR_H_ #define CHECKMATE_ALL_NCHAR_H_ #define USE_RINTERNALS #include #include Rboolean all_nchar(SEXP, R_xlen_t); #endif checkmate/src/all_nchar.c0000644000176200001440000000067013006331417015055 0ustar liggesusers#include "all_nchar.h" Rboolean all_nchar(SEXP x, const R_xlen_t n) { if (!isString(x)) { SEXP xs = PROTECT(coerceVector(x, STRSXP)); Rboolean res = all_nchar(xs, n); UNPROTECT(1); return res; } const R_xlen_t nx = xlength(x); for (R_xlen_t i = 0; i < nx; i++) { if (STRING_ELT(x, i) == NA_STRING || xlength(STRING_ELT(x, i)) < n) return FALSE; } return TRUE; } checkmate/src/any_missing.c0000644000176200001440000000626013006331417015453 0ustar liggesusers#include "any_missing.h" Rboolean any_missing_logical(SEXP x) { const int * xp = LOGICAL(x); const int * const xe = xp + xlength(x); for (; xp != xe; xp++) { if (*xp == NA_LOGICAL) return TRUE; } return FALSE; } Rboolean any_missing_integer(SEXP x) { const int * xp = INTEGER(x); const int * const xe = xp + xlength(x); for (; xp != xe; xp++) { if (*xp == NA_INTEGER) return TRUE; } return FALSE; } Rboolean any_missing_integerish(SEXP x) { switch(TYPEOF(x)) { case LGLSXP: return any_missing_logical(x); case INTSXP: return any_missing_integer(x); case REALSXP: return any_missing_double(x); default: error("Error in any_missing_integerish: x is not logical or numeric"); } } Rboolean any_missing_double(SEXP x) { const double * xp = REAL(x); const double * const xe = xp + xlength(x); for (; xp != xe; xp++) { if (ISNAN(*xp)) return TRUE; } return FALSE; } Rboolean any_missing_numeric(SEXP x) { switch(TYPEOF(x)) { case INTSXP: return any_missing_integer(x); case REALSXP: return any_missing_double(x); default: error("Error in any_missing_numeric: x is not integer or double"); } } Rboolean any_missing_complex(SEXP x) { const Rcomplex * xp = COMPLEX(x); const Rcomplex * const xe = xp + xlength(x); for (; xp != xe; xp++) { if (ISNAN((*xp).r) || ISNAN((*xp).i)) return TRUE; } return FALSE; } Rboolean any_missing_string(SEXP x) { const R_xlen_t nx = xlength(x); for (R_xlen_t i = 0; i < nx; i++) { if (STRING_ELT(x, i) == NA_STRING) return TRUE; } return FALSE; } Rboolean any_missing_atomic(SEXP x) { switch(TYPEOF(x)) { case LGLSXP: return any_missing_logical(x); case INTSXP: return any_missing_integer(x); case REALSXP: return any_missing_double(x); case CPLXSXP: return any_missing_complex(x); case STRSXP: return any_missing_string(x); default: return FALSE; } } Rboolean any_missing_list(SEXP x) { const R_xlen_t nx = xlength(x); for (R_xlen_t i = 0; i < nx; i++) { if (isNull(VECTOR_ELT(x, i))) return TRUE; } return FALSE; } Rboolean any_missing_matrix(SEXP x) { return any_missing_atomic(x); } Rboolean any_missing_frame(SEXP x) { const R_xlen_t nc = xlength(x); for (R_xlen_t i = 0; i < nc; i++) { if (any_missing_atomic(VECTOR_ELT(x, i))) return TRUE; } return FALSE; } Rboolean any_missing(SEXP x) { switch(TYPEOF(x)) { case LGLSXP: return any_missing_logical(x); case INTSXP: return any_missing_integer(x); case REALSXP: return any_missing_double(x); case CPLXSXP: return any_missing_complex(x); case STRSXP: return any_missing_string(x); case NILSXP: return FALSE; case VECSXP: return isFrame(x) ? any_missing_frame(x) : any_missing_list(x); case RAWSXP: return FALSE; default: error("Object of type '%s' not supported", type2char(TYPEOF(x))); } } SEXP c_any_missing(SEXP x) { return ScalarLogical(any_missing(x)); } checkmate/src/any_nan.h0000644000176200001440000000026013006331417014555 0ustar liggesusers#ifndef CHECKMATE_ANY_NAN_H_ #define CHECKMATE_ANY_NAN_H_ #define USE_RINTERNALS #include #include SEXP c_any_nan(SEXP); Rboolean any_nan(SEXP); #endif checkmate/src/guess_type.c0000644000176200001440000000173613006331417015325 0ustar liggesusers#include "guess_type.h" #include const char * guess_type(SEXP x) { SEXP attr = getAttrib(x, R_ClassSymbol); if (!isNull(attr)) { const R_len_t n = length(attr); if (n == 1) return CHAR(STRING_ELT(attr, 0)); /* Constuct name using [class1]/[class2]/... */ static char buf[512]; const char * tmp = CHAR(STRING_ELT(attr, 0)); strncpy(buf, tmp, 512); R_len_t written = strlen(tmp); for (R_len_t i = 1; i < n; i++) { tmp = CHAR(STRING_ELT(attr, i)); if (strlen(tmp) > 512 - written - 1) break; written += snprintf(buf + written, 512 - written, "/%s", tmp); } return buf; } attr = getAttrib(x, R_DimSymbol); if (!isNull(attr) && isVectorAtomic(x)) return length(attr) == 2 ? "matrix" : "array"; return type2char(TYPEOF(x)); } SEXP c_guess_type(SEXP x) { return ScalarString(mkChar(guess_type(x))); } checkmate/src/which_first.h0000644000176200001440000000031113006331417015440 0ustar liggesusers#ifndef CHECKMATE_WHICH_FIRST_H_ #define CHECKMATE_WHICH_FIRST_H_ #define USE_RINTERNALS #include #include SEXP c_which_first(SEXP, SEXP); SEXP c_which_last(SEXP, SEXP); #endif checkmate/src/all_missing.h0000644000176200001440000000110613006331417015433 0ustar liggesusers#ifndef CHECKMATE_ALL_MISSING_H_ #define CHECKMATE_ALL_MISSING_H_ #define USE_RINTERNALS #include #include Rboolean all_missing_logical(SEXP); Rboolean all_missing_integer(SEXP); Rboolean all_missing_integerish(SEXP); Rboolean all_missing_double(SEXP); Rboolean all_missing_numeric(SEXP); Rboolean all_missing_complex(SEXP); Rboolean all_missing_string(SEXP); Rboolean all_missing_atomic(SEXP); Rboolean all_missing_list(SEXP); Rboolean all_missing_matrix(SEXP); Rboolean all_missing_frame(SEXP); Rboolean all_missing(SEXP); SEXP c_all_missing(SEXP); #endif checkmate/src/checks.c0000644000176200001440000005260013006331417014372 0ustar liggesusers#include "checks.h" #include #include #include "is_integerish.h" #include "any_missing.h" #include "any_infinite.h" #include "all_missing.h" #include "all_nchar.h" #include "helper.h" #include "guess_type.h" static char msg[255] = ""; #define HANDLE_TYPE(expr, expected) \ if (!(expr)) { \ snprintf(msg, 255, "Must be of type '%s', not '%s'", expected, guess_type(x)); \ return ScalarString(mkChar(msg)); \ } #define HANDLE_TYPE_NULL(expr, expected, null_ok) \ if (isNull((x))) { \ if (asFlag((null_ok), "null.ok")) \ return ScalarLogical(TRUE); \ snprintf(msg, 255, "Must be of type '%s', not 'NULL'", expected); \ return ScalarString(mkChar(msg)); \ } else { \ if (!(expr)) { \ snprintf(msg, 255, "Must be of type '%s'%s, not '%s'", expected, asFlag(null_ok, "null_ok") ? " (or 'NULL')" : "", guess_type(x)); \ return ScalarString(mkChar(msg)); \ } \ } #define HANDLE_NA(x, na_ok) \ if (is_scalar_na((x))) { \ if (asFlag((na_ok), "na.ok")) \ return ScalarLogical(TRUE); \ return result("May not be NA"); \ }; #define ASSERT_TRUE(x) if (!(x)) return ScalarString(mkChar(msg)); /*********************************************************************************************************************/ /* Some helpers */ /*********************************************************************************************************************/ static Rboolean message(const char *fmt, ...) { va_list vargs; va_start(vargs, fmt); vsnprintf(msg, 255, fmt, vargs); va_end(vargs); return FALSE; } static SEXP result(const char *fmt, ...) { va_list vargs; va_start(vargs, fmt); vsnprintf(msg, 255, fmt, vargs); va_end(vargs); return ScalarString(mkChar(msg)); } static Rboolean check_bounds(SEXP x, SEXP lower, SEXP upper) { double tmp = asNumber(lower, "lower"); if (R_FINITE(tmp)) { if (isReal(x)) { const double *xp = REAL(x); const double * const xend = xp + xlength(x); for (; xp != xend; xp++) { if (!ISNAN(*xp) && *xp < tmp) return message("All elements must be >= %g", tmp); } } else if (isInteger(x)) { const int *xp = INTEGER(x); const int * const xend = xp + xlength(x); for (; xp != xend; xp++) { if (*xp != NA_INTEGER && *xp < tmp) return message("All elements must be >= %g", tmp); } } } tmp = asNumber(upper, "upper"); if (R_FINITE(tmp)) { if (isReal(x)) { const double *xp = REAL(x); const double * const xend = xp + xlength(x); for (; xp != xend; xp++) { if (!ISNAN(*xp) && *xp > tmp) return message("All elements must be <= %g", tmp); } } else if (isInteger(x)) { const int *xp = INTEGER(x); const int * const xend = xp + xlength(x); for (; xp != xend; xp++) { if (*xp != NA_INTEGER && *xp > tmp) return message("All elements must be <= %g", tmp); } } } return TRUE; } static Rboolean check_strict_names(SEXP x) { const R_xlen_t nx = xlength(x); const char *str; for (R_xlen_t i = 0; i < nx; i++) { str = CHAR(STRING_ELT(x, i)); while (*str == '.') str++; if (!isalpha(*str)) return FALSE; for (; *str != '\0'; str++) { if (!isalnum(*str) && *str != '.' && *str != '_') return FALSE; } } return TRUE; } static Rboolean check_names(SEXP nn, const char * type, const char * what) { typedef enum { T_NAMED, T_UNIQUE, T_STRICT } name_t; name_t checks; if (strcmp(type, "unnamed") == 0) return isNull(nn) ? TRUE : message("%s must be unnamed, but has names", what); if (strcmp(type, "named") == 0) { checks = T_NAMED; } else if (strcmp(type, "unique") == 0) { checks = T_UNIQUE; } else if (strcmp(type, "strict") == 0) { checks = T_STRICT; } else { error("Unknown type '%s' to specify check for names. Supported are 'unnamed', 'named', 'unique' and 'strict'.", type); } if (isNull(nn) || any_missing_string(nn) || !all_nchar(nn, 1)) return message("%s must be named", what); if (checks >= T_UNIQUE) { if (any_duplicated(nn, FALSE) != 0) return message("%s must be uniquely named", what); if (checks >= T_STRICT && !check_strict_names(nn)) return message("%s must be named according to R's variable naming rules", what); } return TRUE; } static Rboolean check_vector_len(SEXP x, SEXP len, SEXP min_len, SEXP max_len) { if (!isNull(len)) { R_xlen_t n = asCount(len, "len"); if (xlength(x) != n) return message("Must have length %g, but has length %g", (double)n, (double)xlength(x)); } if (!isNull(min_len)) { R_xlen_t n = asCount(min_len, "min.len"); if (xlength(x) < n) return message("Must have length >= %g, but has length %g", (double)n, (double)xlength(x)); } if (!isNull(max_len)) { R_xlen_t n = asCount(max_len, "max.len"); if (xlength(x) > n) return message("Must have length <= %g, but has length %g", (double)n, (double)xlength(x)); } return TRUE; } static Rboolean check_vector_missings(SEXP x, SEXP any_missing, SEXP all_missing) { if (!asFlag(any_missing, "any.missing") && any_missing_atomic(x)) return message("Contains missing values"); if (!asFlag(all_missing, "all.missing") && all_missing_atomic(x)) return message("Contains only missing values"); return TRUE; } static Rboolean check_vector_unique(SEXP x, SEXP unique) { if (asFlag(unique, "unique") && any_duplicated(x, FALSE) > 0) return message("Contains duplicated values"); return TRUE; } static Rboolean check_vector_names(SEXP x, SEXP names) { if (!isNull(names) && xlength(x) > 0) return check_names(getAttrib(x, R_NamesSymbol), asString(names, "names"), "Vector"); return TRUE; } static Rboolean check_vector_finite(SEXP x, SEXP finite) { if (asFlag(finite, "finite") && any_infinite(x)) return message("Must be finite"); return TRUE; } static Rboolean check_matrix_dims(SEXP x, SEXP min_rows, SEXP min_cols, SEXP rows, SEXP cols) { if (!isNull(min_rows) || !isNull(rows)) { R_len_t xrows = get_nrows(x); if (!isNull(min_rows)) { R_len_t cmp = asCount(min_rows, "min.rows"); if (xrows < cmp) return message("Must have at least %i rows, but has %i rows", cmp, xrows); } if (!isNull(rows)) { R_len_t cmp = asCount(rows, "rows"); if (xrows != cmp) return message("Must have exactly %i rows, but has %i rows", cmp, xrows); } } if (!isNull(min_cols) || !isNull(cols)) { R_len_t xcols = get_ncols(x); if (!isNull(min_cols)) { R_len_t cmp = asCount(min_cols, "min.cols"); if (xcols < cmp) return message("Must have at least %i cols, but has %i cols", cmp, xcols); } if (!isNull(cols)) { R_len_t cmp = asCount(cols, "cols"); if (xcols != cmp) return message("Must have exactly %i cols, but has %i cols", cmp, xcols); } } return TRUE; } static Rboolean check_storage(SEXP x, SEXP mode) { if (!isNull(mode)) { const char * const storage = asString(mode, "mode"); if (strcmp(storage, "logical") == 0) { if (!isLogical(x)) return message("Must store logicals"); } else if (strcmp(storage, "integer") == 0) { if (!isInteger(x)) return message("Must store integers"); } else if (strcmp(storage, "double") == 0) { if (!isReal(x)) return message("Must store doubles"); } else if (strcmp(storage, "integerish") == 0) { if (!isIntegerish(x, INTEGERISH_DEFAULT_TOL, FALSE)) return message("Must store integerish values"); } else if (strcmp(storage, "numeric") == 0) { if (!isStrictlyNumeric(x)) return message("Must store numerics"); } else if (strcmp(storage, "complex") == 0) { if (!isComplex(x)) return message("Must store complexs"); } else if (strcmp(storage, "character") == 0) { if (!isString(x)) return message("Must store characters"); } else if (strcmp(storage, "list") == 0) { if (!isRList(x)) return message("Must store a list"); } else if (strcmp(storage, "atomic") == 0) { if (!isVectorAtomic(x)) return message("Must be atomic"); } else { error("Invalid argument 'mode'. Must be one of 'logical', 'integer', 'integerish', 'double', 'numeric', 'complex', 'character', 'list' or 'atomic'"); } } return TRUE; } static inline Rboolean is_scalar_na(SEXP x) { if (xlength(x) == 1) { switch(TYPEOF(x)) { case LGLSXP: return (LOGICAL(x)[0] == NA_LOGICAL); case INTSXP: return (INTEGER(x)[0] == NA_INTEGER); case REALSXP: return ISNAN(REAL(x)[0]); case STRSXP: return (STRING_ELT(x, 0) == NA_STRING); } } return FALSE; } /*********************************************************************************************************************/ /* Exported check functions */ /*********************************************************************************************************************/ SEXP c_check_character(SEXP x, SEXP min_chars, SEXP any_missing, SEXP all_missing, SEXP len, SEXP min_len, SEXP max_len, SEXP unique, SEXP names, SEXP null_ok) { HANDLE_TYPE_NULL(isString(x) || all_missing_atomic(x), "character", null_ok); ASSERT_TRUE(check_vector_len(x, len, min_len, max_len)); ASSERT_TRUE(check_vector_names(x, names)); ASSERT_TRUE(check_vector_missings(x, any_missing, all_missing)); if (!isNull(min_chars)) { R_xlen_t n = asCount(min_chars, "min.chars"); if (n > 0 && !all_nchar(x, n)) return result("All elements must have at least %i characters", n); } ASSERT_TRUE(check_vector_unique(x, unique)); return ScalarLogical(TRUE); } SEXP c_check_complex(SEXP x, SEXP any_missing, SEXP all_missing, SEXP len, SEXP min_len, SEXP max_len, SEXP unique, SEXP names, SEXP null_ok) { HANDLE_TYPE_NULL(isComplex(x) || all_missing_atomic(x), "complex", null_ok); ASSERT_TRUE(check_vector_len(x, len, min_len, max_len)); ASSERT_TRUE(check_vector_names(x, names)); ASSERT_TRUE(check_vector_missings(x, any_missing, all_missing)); ASSERT_TRUE(check_vector_unique(x, unique)); return ScalarLogical(TRUE); } SEXP c_check_dataframe(SEXP x, SEXP any_missing, SEXP all_missing, SEXP min_rows, SEXP min_cols, SEXP rows, SEXP cols, SEXP row_names, SEXP col_names, SEXP null_ok) { HANDLE_TYPE_NULL(isFrame(x), "data.frame", null_ok); ASSERT_TRUE(check_matrix_dims(x, min_rows, min_cols, rows, cols)); if (!isNull(row_names)) { SEXP nn = getAttrib(x, install("row.names")); if (isInteger(nn)) { nn = PROTECT(coerceVector(nn, STRSXP)); Rboolean ok = check_names(nn, asString(row_names, "row.names"), "Rows"); UNPROTECT(1); if (!ok) return ScalarString(mkChar(msg)); } else { ASSERT_TRUE(check_names(nn, asString(row_names, "row.names"), "Rows")); } } if (!isNull(col_names)) ASSERT_TRUE(check_names(getAttrib(x, R_NamesSymbol), asString(col_names, "col.names"), "Columns")); if (!asFlag(any_missing, "any.missing") && any_missing_frame(x)) return result("Contains missing values"); if (!asFlag(all_missing, "all.missing") && all_missing_frame(x)) return result("Contains only missing values"); return ScalarLogical(TRUE); } SEXP c_check_factor(SEXP x, SEXP any_missing, SEXP all_missing, SEXP len, SEXP min_len, SEXP max_len, SEXP unique, SEXP names, SEXP null_ok) { HANDLE_TYPE_NULL(isFactor(x) || all_missing_atomic(x), "factor", null_ok); ASSERT_TRUE(check_vector_len(x, len, min_len, max_len)); ASSERT_TRUE(check_vector_names(x, names)); ASSERT_TRUE(check_vector_missings(x, any_missing, all_missing)); ASSERT_TRUE(check_vector_unique(x, unique)); return ScalarLogical(TRUE); } SEXP c_check_integer(SEXP x, SEXP lower, SEXP upper, SEXP any_missing, SEXP all_missing, SEXP len, SEXP min_len, SEXP max_len, SEXP unique, SEXP names, SEXP null_ok) { HANDLE_TYPE_NULL(isInteger(x) || all_missing_atomic(x), "integer", null_ok); ASSERT_TRUE(check_vector_len(x, len, min_len, max_len)); ASSERT_TRUE(check_vector_names(x, names)); ASSERT_TRUE(check_vector_missings(x, any_missing, all_missing)); ASSERT_TRUE(check_bounds(x, lower, upper)); ASSERT_TRUE(check_vector_unique(x, unique)); return ScalarLogical(TRUE); } SEXP c_check_integerish(SEXP x, SEXP tol, SEXP lower, SEXP upper, SEXP any_missing, SEXP all_missing, SEXP len, SEXP min_len, SEXP max_len, SEXP unique, SEXP names, SEXP null_ok) { double dtol = asNumber(tol, "tol"); HANDLE_TYPE_NULL(isIntegerish(x, dtol, FALSE) || all_missing_atomic(x), "integerish", null_ok); ASSERT_TRUE(check_vector_len(x, len, min_len, max_len)); ASSERT_TRUE(check_vector_names(x, names)); ASSERT_TRUE(check_vector_missings(x, any_missing, all_missing)); ASSERT_TRUE(check_bounds(x, lower, upper)); ASSERT_TRUE(check_vector_unique(x, unique)); return ScalarLogical(TRUE); } SEXP c_check_list(SEXP x, SEXP any_missing, SEXP all_missing, SEXP len, SEXP min_len, SEXP max_len, SEXP unique, SEXP names, SEXP null_ok) { HANDLE_TYPE_NULL(isRList(x), "list", null_ok) ASSERT_TRUE(check_vector_len(x, len, min_len, max_len)); ASSERT_TRUE(check_vector_names(x, names)); ASSERT_TRUE(check_vector_missings(x, any_missing, all_missing)); ASSERT_TRUE(check_vector_unique(x, unique)); return ScalarLogical(TRUE); } SEXP c_check_logical(SEXP x, SEXP any_missing, SEXP all_missing, SEXP len, SEXP min_len, SEXP max_len, SEXP unique, SEXP names, SEXP null_ok) { HANDLE_TYPE_NULL(isLogical(x) || all_missing_atomic(x), "logical", null_ok); ASSERT_TRUE(check_vector_len(x, len, min_len, max_len)); ASSERT_TRUE(check_vector_names(x, names)); ASSERT_TRUE(check_vector_missings(x, any_missing, all_missing)); ASSERT_TRUE(check_vector_unique(x, unique)); return ScalarLogical(TRUE); } SEXP c_check_matrix(SEXP x, SEXP mode, SEXP any_missing, SEXP all_missing, SEXP min_rows, SEXP min_cols, SEXP rows, SEXP cols, SEXP row_names, SEXP col_names, SEXP null_ok) { HANDLE_TYPE_NULL(isMatrix(x), "matrix", null_ok); ASSERT_TRUE(check_storage(x, mode)); ASSERT_TRUE(check_matrix_dims(x, min_rows, min_cols, rows, cols)); if (!isNull(row_names) && xlength(x) > 0) { SEXP nn = getAttrib(x, R_DimNamesSymbol); if (!isNull(nn)) nn = VECTOR_ELT(nn, 0); ASSERT_TRUE(check_names(nn, asString(row_names, "row.names"), "Rows")); } if (!isNull(col_names) && xlength(x) > 0) { SEXP nn = getAttrib(x, R_DimNamesSymbol); if (!isNull(nn)) nn = VECTOR_ELT(nn, 1); ASSERT_TRUE(check_names(nn, asString(col_names, "col.names"), "Columns")); } ASSERT_TRUE(check_vector_missings(x, any_missing, all_missing)); return ScalarLogical(TRUE); } SEXP c_check_array(SEXP x, SEXP mode, SEXP any_missing, SEXP d, SEXP min_d, SEXP max_d, SEXP null_ok) { HANDLE_TYPE_NULL(isArray(x), "array", null_ok); ASSERT_TRUE(check_storage(x, mode)); if (!asFlag(any_missing, "any.missing") && any_missing_atomic(x)) return result("Contains missing values"); R_len_t ndim = length(getAttrib(x, R_DimSymbol)); if (!isNull(d)) { R_len_t di = asCount(d, "d"); if (ndim != di) return result("Must be a %i-d array, but has dimension %i", di, ndim); } if (!isNull(min_d)) { R_len_t di = asCount(min_d, "min.d"); if (ndim < di) return result("Must have >=%i dimensions, but has dimension %i", di, ndim); } if (!isNull(max_d)) { R_len_t di = asCount(max_d, "max.d"); if (ndim > di) return result("Must have <=%i dimensions, but has dimension %i", di, ndim); } return ScalarLogical(TRUE); } SEXP c_check_named(SEXP x, SEXP type) { if (!isNull(type) && xlength(x) > 0) ASSERT_TRUE(check_names(getAttrib(x, R_NamesSymbol), asString(type, "type"), "Object")); return ScalarLogical(TRUE); } SEXP c_check_names(SEXP x, SEXP type) { if (!isString(x)) return result("Must be a character vector of names"); ASSERT_TRUE(check_names(x, asString(type, "type"), "Names")); return ScalarLogical(TRUE); } SEXP c_check_numeric(SEXP x, SEXP lower, SEXP upper, SEXP finite, SEXP any_missing, SEXP all_missing, SEXP len, SEXP min_len, SEXP max_len, SEXP unique, SEXP names, SEXP null_ok) { HANDLE_TYPE_NULL(isStrictlyNumeric(x) || all_missing_atomic(x), "numeric", null_ok); ASSERT_TRUE(check_vector_len(x, len, min_len, max_len)); ASSERT_TRUE(check_vector_names(x, names)); ASSERT_TRUE(check_vector_missings(x, any_missing, all_missing)); ASSERT_TRUE(check_bounds(x, lower, upper)); ASSERT_TRUE(check_vector_finite(x, finite)); ASSERT_TRUE(check_vector_unique(x, unique)); return ScalarLogical(TRUE); } SEXP c_check_vector(SEXP x, SEXP strict, SEXP any_missing, SEXP all_missing, SEXP len, SEXP min_len, SEXP max_len, SEXP unique, SEXP names, SEXP null_ok) { HANDLE_TYPE_NULL(isVector(x), "vector", null_ok); if (asFlag(strict, "strict")) { SEXP attr = ATTRIB(x); HANDLE_TYPE( (length(attr) == 0 || (TAG(attr) == R_NamesSymbol)) && CDR(attr) == R_NilValue, "vector"); } ASSERT_TRUE(check_vector_len(x, len, min_len, max_len)); ASSERT_TRUE(check_vector_names(x, names)); ASSERT_TRUE(check_vector_missings(x, any_missing, all_missing)); ASSERT_TRUE(check_vector_unique(x, unique)); return ScalarLogical(TRUE); } SEXP c_check_atomic(SEXP x, SEXP any_missing, SEXP all_missing, SEXP len, SEXP min_len, SEXP max_len, SEXP unique, SEXP names) { HANDLE_TYPE(isNull(x) || isVectorAtomic(x), "atomic"); ASSERT_TRUE(check_vector_len(x, len, min_len, max_len)); ASSERT_TRUE(check_vector_names(x, names)); ASSERT_TRUE(check_vector_missings(x, any_missing, all_missing)); ASSERT_TRUE(check_vector_unique(x, unique)); return ScalarLogical(TRUE); } SEXP c_check_atomic_vector(SEXP x, SEXP any_missing, SEXP all_missing, SEXP len, SEXP min_len, SEXP max_len, SEXP unique, SEXP names) { HANDLE_TYPE(isAtomicVector(x), "atomic vector"); ASSERT_TRUE(check_vector_len(x, len, min_len, max_len)); ASSERT_TRUE(check_vector_names(x, names)); ASSERT_TRUE(check_vector_missings(x, any_missing, all_missing)); ASSERT_TRUE(check_vector_unique(x, unique)); return ScalarLogical(TRUE); } SEXP c_check_flag(SEXP x, SEXP na_ok, SEXP null_ok) { HANDLE_NA(x, na_ok); HANDLE_TYPE_NULL(isLogical(x), "logical flag", null_ok); if (xlength(x) != 1) return result("Must have length 1"); return ScalarLogical(TRUE); } SEXP c_check_count(SEXP x, SEXP na_ok, SEXP positive, SEXP tol, SEXP null_ok) { HANDLE_NA(x, na_ok) double dtol = asNumber(tol, "tol"); HANDLE_TYPE_NULL(isIntegerish(x, dtol, FALSE), "count", null_ok); if (xlength(x) != 1) return result("Must have length 1"); const int pos = (int) asFlag(positive, "positive"); if (asInteger(x) < pos) return result("Must be >= %i", pos); return ScalarLogical(TRUE); } SEXP c_check_int(SEXP x, SEXP na_ok, SEXP lower, SEXP upper, SEXP tol, SEXP null_ok) { double dtol = asNumber(tol, "tol"); HANDLE_NA(x, na_ok); HANDLE_TYPE_NULL(isIntegerish(x, dtol, FALSE), "single integerish value", null_ok); if (xlength(x) != 1) return result("Must have length 1"); ASSERT_TRUE(check_bounds(x, lower, upper)); return ScalarLogical(TRUE); } SEXP c_check_number(SEXP x, SEXP na_ok, SEXP lower, SEXP upper, SEXP finite, SEXP null_ok) { HANDLE_NA(x, na_ok); HANDLE_TYPE_NULL(isStrictlyNumeric(x), "number", null_ok); if (xlength(x) != 1) return result("Must have length 1"); ASSERT_TRUE(check_vector_finite(x, finite)); ASSERT_TRUE(check_bounds(x, lower, upper)); return ScalarLogical(TRUE); } SEXP c_check_string(SEXP x, SEXP na_ok, SEXP min_chars, SEXP null_ok) { HANDLE_NA(x, na_ok); HANDLE_TYPE_NULL(isString(x), "string", null_ok); if (xlength(x) != 1) return result("Must have length 1"); if (!isNull(min_chars)) { R_xlen_t n = asCount(min_chars, "min.chars"); if (!all_nchar(x, n)) return result("Must have at least %i characters", n); } return ScalarLogical(TRUE); } SEXP c_check_scalar(SEXP x, SEXP na_ok, SEXP null_ok) { HANDLE_NA(x, na_ok); HANDLE_TYPE_NULL(isVectorAtomic(x), "atomic scalar", null_ok); if (xlength(x) != 1) return result("Must have length 1"); return ScalarLogical(TRUE); } #undef HANDLE_TYPE #undef HANDLE_TYPE_NULL #undef HANDLE_NA #undef ASSERT_TRUE checkmate/src/checkmate_init.c0000644000176200001440000000034013006331417016073 0ustar liggesusers#include "qassert.h" #include void R_init_checkmate(DllInfo *info) { R_RegisterCCallable("checkmate", "qtest", (DL_FUNC) &qtest); R_RegisterCCallable("checkmate", "qassert", (DL_FUNC) &qassert); } checkmate/src/any_missing.h0000644000176200001440000000110613006331417015452 0ustar liggesusers#ifndef CHECKMATE_ANY_MISSING_H_ #define CHECKMATE_ANY_MISSING_H_ #define USE_RINTERNALS #include #include Rboolean any_missing_logical(SEXP); Rboolean any_missing_integer(SEXP); Rboolean any_missing_integerish(SEXP); Rboolean any_missing_double(SEXP); Rboolean any_missing_numeric(SEXP); Rboolean any_missing_complex(SEXP); Rboolean any_missing_string(SEXP); Rboolean any_missing_atomic(SEXP); Rboolean any_missing_list(SEXP); Rboolean any_missing_matrix(SEXP); Rboolean any_missing_frame(SEXP); Rboolean any_missing(SEXP); SEXP c_any_missing(SEXP); #endif checkmate/src/qassert.c0000644000176200001440000004613713006331417014624 0ustar liggesusers#include "qassert.h" #include "helper.h" #include "guess_type.h" #include "any_missing.h" #include "is_integerish.h" typedef enum { CL_LOGICAL, CL_INTEGER, CL_INTEGERISH, CL_NUMERIC, CL_DOUBLE, CL_STRING, CL_FACTOR, CL_LIST, CL_COMPLEX, CL_ATOMIC, CL_ATOMIC_VECTOR, CL_MATRIX, CL_DATAFRAME, CL_FUNCTION, CL_ENVIRONMENT, CL_NULL, CL_NONE } class_t; static const char * CLSTR[] = { "logical", "integer", "integerish", "numeric", "double", "string", "factor", "list", "complex", "atomic", "atomic vector", "matrix", "data frame", "function", "environment", "NULL" }; typedef enum { LT, LE, EQ, GE, GT, NE, NONE } cmp_t; static const char * CMPSTR[] = { "<", "<=", "==", ">=", ">", "!=" }; typedef Rboolean(*dd_cmp)(double, double); typedef Rboolean(*ll_cmp)(R_xlen_t, R_xlen_t); typedef struct { dd_cmp fun; double cmp; cmp_t op; } bound_t; typedef struct { struct { Rboolean(*fun)(SEXP); class_t name; } class; struct { Rboolean(*fun)(SEXP); } missing; struct { ll_cmp fun; R_xlen_t cmp; cmp_t op; } len; bound_t lower; bound_t upper; } checker_t; typedef struct { Rboolean ok; char msg[255]; } msg_t; static inline Rboolean ii_eq(const R_xlen_t x, const R_xlen_t y) { return x == y; } static inline Rboolean ii_lt(const R_xlen_t x, const R_xlen_t y) { return x < y; } static inline Rboolean ii_gt(const R_xlen_t x, const R_xlen_t y) { return x > y; } static inline Rboolean ii_le(const R_xlen_t x, const R_xlen_t y) { return x <= y; } static inline Rboolean ii_ge(const R_xlen_t x, const R_xlen_t y) { return x >= y; } static inline Rboolean dd_lt(const double x, const double y) { return x < y; } static inline Rboolean dd_gt(const double x, const double y) { return x > y; } static inline Rboolean dd_le(const double x, const double y) { return x <= y; } static inline Rboolean dd_ge(const double x, const double y) { return x >= y; } static inline Rboolean dd_ne(const double x, const double y) { return x != y; } static inline Rboolean is_class_logical(SEXP x) { return isLogical(x); } static inline Rboolean is_class_integer(SEXP x) { return isInteger(x); } static inline Rboolean is_class_integerish(SEXP x) { return isIntegerish(x, INTEGERISH_DEFAULT_TOL, TRUE); } static inline Rboolean is_class_double(SEXP x) { return isReal(x); } static inline Rboolean is_class_numeric(SEXP x) { return isStrictlyNumeric(x); } static inline Rboolean is_class_complex(SEXP x) { return isComplex(x); } static inline Rboolean is_class_string(SEXP x) { return isString(x); } static inline Rboolean is_class_factor(SEXP x) { return isFactor(x); } static inline Rboolean is_class_atomic(SEXP x) { return isNull(x) || isVectorAtomic(x); } static inline Rboolean is_class_atomic_vector(SEXP x) { return isAtomicVector(x); } static inline Rboolean is_class_list(SEXP x) { return isRList(x); } static inline Rboolean is_class_matrix(SEXP x) { return isMatrix(x); } static inline Rboolean is_class_frame(SEXP x) { return isFrame(x); } static inline Rboolean is_class_function(SEXP x) { return isFunction(x); } static inline Rboolean is_class_environment(SEXP x) { return isEnvironment(x); } static inline Rboolean is_class_null(SEXP x) { return isNull(x); } static const msg_t MSGT = { .ok = TRUE }; static const msg_t MSGF = { .ok = FALSE }; static msg_t message(const char *fmt, ...) { msg_t msg = { .ok = FALSE }; va_list vargs; va_start(vargs, fmt); vsnprintf(msg.msg, 255, fmt, vargs); va_end(vargs); return msg; } /*********************************************************************************************************************/ /* Some helper functions */ /*********************************************************************************************************************/ static msg_t check_bound(SEXP x, const bound_t bound) { if (isReal(x)) { const double *xp = REAL(x); const double * const xend = xp + xlength(x); for (; xp != xend; xp++) { if (!ISNAN(*xp) && !bound.fun(*xp, bound.cmp)) { if (bound.cmp == R_PosInf) return message("All elements must be %s Inf", CMPSTR[bound.op]); if (bound.cmp == R_NegInf) return message("All elements must be %s -Inf", CMPSTR[bound.op]); return message("All elements must be %s %g", CMPSTR[bound.op], bound.cmp); } } } else if (isInteger(x)) { const int *xp = INTEGER(x); const int * const xend = xp + xlength(x); for (; xp != xend; xp++) { if (*xp != NA_INTEGER && !bound.fun((double) *xp, bound.cmp)) return message("All elements must be %s %g", CMPSTR[bound.op], bound.cmp); } } else if (isString(x)) { const R_xlen_t nx = xlength(x); double nchar; for (R_xlen_t i = 0; i < nx; i++) { nchar = STRING_ELT(x, i) == NA_STRING ? 0. : (double)length(STRING_ELT(x, i)); if (!bound.fun(nchar, bound.cmp)) return message("All elements must have %s %g chars", CMPSTR[bound.op], bound.cmp); } } else if (isFactor(x)) { return check_bound(getAttrib(x, R_LevelsSymbol), bound); } else { error("Bound checks only possible for numeric variables, strings and factors, not %s", guess_type(x)); } return MSGT; } /*********************************************************************************************************************/ /* First step: Parse string and built checker_t object */ /*********************************************************************************************************************/ static int parse_class(checker_t *checker, const char *rule) { checker->missing.fun = NULL; switch(rule[0]) { case 'B': checker->missing.fun = &any_missing_logical; case 'b': checker->class.fun = &is_class_logical; checker->class.name = CL_LOGICAL; break; case 'I': checker->missing.fun = &any_missing_integer; case 'i': checker->class.fun = &is_class_integer; checker->class.name = CL_INTEGER; break; case 'X': checker->missing.fun = &any_missing_integerish; case 'x': checker->class.fun = &is_class_integerish; checker->class.name = CL_INTEGERISH; break; case 'N': checker->missing.fun = &any_missing_numeric; case 'n': checker->class.fun = &is_class_numeric; checker->class.name = CL_NUMERIC; break; case 'R': checker->missing.fun = &any_missing_double; case 'r': checker->class.fun = &is_class_double; checker->class.name = CL_DOUBLE; break; case 'S': checker->missing.fun = &any_missing_string; case 's': checker->class.fun = &is_class_string; checker->class.name = CL_STRING; break; case 'F': checker->missing.fun = &any_missing_integer; case 'f': checker->class.fun = &is_class_factor; checker->class.name = CL_FACTOR; break; case 'L': checker->missing.fun = &any_missing_list; case 'l': checker->class.fun = &is_class_list; checker->class.name = CL_LIST; break; case 'C': checker->missing.fun = &any_missing_complex; case 'c': checker->class.fun = &is_class_complex; checker->class.name = CL_COMPLEX; break; case 'A': checker->missing.fun = &any_missing_atomic; case 'a': checker->class.fun = &is_class_atomic; checker->class.name = CL_ATOMIC; break; case 'V': checker->missing.fun = &any_missing_atomic; case 'v': checker->class.fun = &is_class_atomic_vector; checker->class.name = CL_ATOMIC_VECTOR; break; case 'M': checker->missing.fun = &any_missing_matrix; case 'm': checker->class.fun = &is_class_matrix; checker->class.name = CL_MATRIX; break; case 'D': checker->missing.fun = &any_missing_frame; case 'd': checker->class.fun = &is_class_frame; checker->class.name = CL_DATAFRAME; break; /* case 'g': */ /* checker->class.fun = &is_class_function; */ /* checker->class.name = CL_FUNCTION; */ /* break; */ case 'e': checker->class.fun = &is_class_environment; checker->class.name = CL_ENVIRONMENT; break; case '0': checker->class.fun = &is_class_null; checker->class.name = CL_NULL; break; case '*': checker->class.fun = NULL; checker->class.name = CL_NONE; break; default: error("Unknown class identifier '%c'", rule[0]); } return 1; } static int parse_length(checker_t *checker, const char *rule) { switch(rule[0]) { case '*': checker->len.fun = NULL; return 1; case '?': checker->len.fun = &ii_le; checker->len.cmp = 1; checker->len.op = LE; return 1; case '+': checker->len.fun = &ii_ge; checker->len.cmp = 1; checker->len.op = GE; return 1; case '(': case '[': case '\0': checker->len.fun = NULL; checker->len.op = NONE; return 0; } const char *start = rule; switch(rule[0]) { case '=': checker->len.fun = &ii_eq; checker->len.op = EQ; start += 1 + (rule[1] == '='); break; case '<': if (rule[1] == '=') { checker->len.fun = &ii_le; checker->len.op = LE; start += 2; } else { checker->len.fun = &ii_lt; checker->len.op = LE; start += 1; } break; case '>': if (rule[1] == '=') { checker->len.fun = &ii_ge; checker->len.op = GE; start += 2; } else { checker->len.fun = &ii_gt; checker->len.op = GT; start += 1; } break; default: checker->len.fun = &ii_eq; checker->len.op = EQ; break; } char *end; long int cmp = strtol(start, &end, 10); if (start == end) error("Invalid length definition: %s", rule); if (cmp >= INT_MAX) error("Cannot handle length >= %i", INT_MAX); if (cmp < 0) error("Cannot check for negative length"); checker->len.cmp = (int)cmp; return end - rule; } static int parse_bounds(checker_t *checker, const char *rule) { switch(rule[0]) { case '\0': checker->lower.fun = NULL; checker->upper.fun = NULL; return 0; case '(': checker->lower.fun = &dd_gt; checker->lower.op = GT; break; case '[': checker->lower.fun = &dd_ge; checker->lower.op = GE; break; default: error("Invalid bound definition, missing opening '(' or '[': %s", rule); } char *end; const char *start = rule + 1; double cmp = strtod(start, &end); if (start == end) { if (checker->lower.op == GT) { checker->lower.fun = &dd_ne; checker->lower.cmp = R_NegInf; checker->lower.op = NE; } else { checker->lower.fun = NULL; } } else { checker->lower.cmp = cmp; } switch(*end) { case ',' : start = end + 1; case ')' : case ']' : break; default : error("Invalid bound definition, error parsing lower bound, missing separator ',' or missing closing ')' or ']': %s", rule); } cmp = strtod(start, &end); if (*end == ')') { if (start == end) { checker->upper.fun = &dd_ne; checker->upper.cmp = R_PosInf; checker->upper.op = NE; } else { checker->upper.fun = &dd_lt; checker->upper.cmp = cmp; checker->upper.op = LT; } } else if (*end == ']') { if (start == end) { checker->upper.fun = NULL; } else { checker->upper.fun = &dd_le; checker->upper.cmp = cmp; checker->upper.op = LE; } } else { error("Invalid bound definition, error parsing upper bound or missing closing ')' or ']': %s", rule); } return end - rule + 1; } static void parse_rule(checker_t *checker, const char *rule) { const R_len_t nchars = strlen(rule); if (nchars == 0) error("Empty rule"); rule += parse_class(checker, rule); rule += parse_length(checker, rule); rule += parse_bounds(checker, rule); if (rule[0] == '\0') return; error("Additional chars found!"); } /*********************************************************************************************************************/ /* Second step: check SEXP using a checker_t object */ /*********************************************************************************************************************/ static msg_t check_rule(SEXP x, const checker_t *checker, const Rboolean err_msg) { if (checker->class.fun != NULL && !checker->class.fun(x)) { return err_msg ? message("Must be of class '%s', not '%s'", CLSTR[checker->class.name], guess_type(x)) : MSGF; } if (checker->missing.fun != NULL && checker->missing.fun(x)) { return err_msg ? message("May not contain missing values") : MSGF; } if (checker->len.fun != NULL && !checker->len.fun(xlength(x), checker->len.cmp)) { return err_msg ? message("Must be of length %s %i, but has length %g", CMPSTR[checker->len.op], checker->len.cmp, (double)xlength(x)) : MSGF; } if (checker->lower.fun != NULL) { msg_t msg = check_bound(x, checker->lower); if (!msg.ok) return msg; } if (checker->upper.fun != NULL) { msg_t msg = check_bound(x, checker->upper); if (!msg.ok) return msg; } return MSGT; } /*********************************************************************************************************************/ /* qassert stuff */ /*********************************************************************************************************************/ static inline R_len_t qassert1(SEXP x, const checker_t *checker, msg_t *result, const R_len_t nrules) { for (R_len_t i = 0; i < nrules; i++) { result[i] = check_rule(x, &checker[i], result[i].ok); if (result[i].ok) return 0; } return 1; } static inline R_len_t qassert_list(SEXP x, const checker_t *checker, msg_t *result, const R_len_t nrules) { if (!isNewList(x) || isNull(x)) error("Argument 'x' must be a list or data.frame"); const R_len_t nx = xlength(x); for (R_xlen_t i = 0; i < nx; i++) { if (qassert1(VECTOR_ELT(x, i), checker, result, nrules) != 0) return i + 1; } return 0; } /* exported for other packages */ SEXP qassert(SEXP x, const char *rule, const char *name) { checker_t checker; parse_rule(&checker, rule); msg_t result = check_rule(x, &checker, TRUE); if (!result.ok) error("Variable '%s': %s", name, result.msg); return x; } SEXP c_qassert(SEXP x, SEXP rules, SEXP recursive) { const Rboolean nrules = length(rules); R_len_t failed; if (!isString(rules)) error("Argument 'rules' must be a string"); if (nrules == 0) return ScalarLogical(TRUE); msg_t result[nrules]; checker_t checker[nrules]; SEXP tmp; for (R_len_t i = 0; i < nrules; i++) { tmp = STRING_ELT(rules, i); if (tmp == NA_STRING) error("Rule may not be NA"); parse_rule(&checker[i], CHAR(tmp)); result[i].ok = TRUE; } if (LOGICAL(recursive)[0]) { failed = qassert_list(x, checker, result, nrules); } else { failed = qassert1(x, checker, result, nrules); } if (failed == 0) return ScalarLogical(TRUE); SEXP msgs = PROTECT(allocVector(STRSXP, nrules)); SEXP pos = PROTECT(ScalarInteger(failed)); setAttrib(msgs, install("pos"), pos); for (R_len_t i = 0; i < nrules; i++) SET_STRING_ELT(msgs, i, mkChar(result[i].msg)); UNPROTECT(2); return msgs; } /*********************************************************************************************************************/ /* qtest stuff */ /*********************************************************************************************************************/ static inline Rboolean qtest1(SEXP x, const checker_t *checker, const R_len_t nrules) { msg_t result; for (R_len_t i = 0; i < nrules; i++) { result = check_rule(x, &checker[i], FALSE); if (result.ok) return TRUE; } return FALSE; } static inline Rboolean qtest_list(SEXP x, const checker_t *checker, const R_len_t nrules, R_len_t depth) { if (!isNewList(x) || isNull(x)) error("Argument 'x' must be a list or data.frame"); const R_len_t nx = xlength(x); if (depth > 1) { for (R_xlen_t i = 0; i < nx; i++) { if (isRList(VECTOR_ELT(x, i))) { if (!qtest_list(VECTOR_ELT(x, i), checker, nrules, depth - 1)) return FALSE; } else { if (!qtest1(VECTOR_ELT(x, i), checker, nrules)) return FALSE; } } } else { for (R_xlen_t i = 0; i < nx; i++) { if (!qtest1(VECTOR_ELT(x, i), checker, nrules)) return FALSE; } } return TRUE; } /* exported for other packages */ Rboolean qtest(SEXP x, const char *rule) { checker_t checker; parse_rule(&checker, rule); return qtest1(x, &checker, 1); } SEXP c_qtest(SEXP x, SEXP rules, SEXP recursive, SEXP depth) { const R_len_t nrules = length(rules); if (!isString(rules)) error("Argument 'rules' must be a string"); if (nrules == 0) return ScalarLogical(TRUE); checker_t checker[nrules]; SEXP tmp; for (R_len_t i = 0; i < nrules; i++) { tmp = STRING_ELT(rules, i); if (tmp == NA_STRING) error("Rule may not be NA"); parse_rule(&checker[i], CHAR(STRING_ELT(rules, i))); } if (LOGICAL(recursive)[0]) return ScalarLogical(qtest_list(x, checker, nrules, asCount(depth, "depth"))); return ScalarLogical(qtest1(x, checker, nrules)); } checkmate/src/is_integerish.c0000644000176200001440000000233113006331417015762 0ustar liggesusers#include "is_integerish.h" #include #include static inline Rboolean is_unconvertible(const double x, const double tol) { return (!ISNAN(x) && (x <= INT_MIN || x > INT_MAX || fabs(x - nearbyint(x)) >= tol)); } static Rboolean is_integerish_double(SEXP x, const double tol) { const double *xr = REAL(x); const double * const xend = xr + length(x); for (; xr != xend; xr++) { if (is_unconvertible(*xr, tol)) return FALSE; } return TRUE; } static Rboolean is_integerish_complex(SEXP x, const double tol) { const Rcomplex * xc = COMPLEX(x); const Rcomplex * const xe = xc + length(x); for (; xc != xe; xc++) { if (fabs((*xc).i) >= tol || is_unconvertible((*xc).r, tol)) return FALSE; } return TRUE; } Rboolean isIntegerish(SEXP x, const double tol, Rboolean logicals_ok) { switch(TYPEOF(x)) { case LGLSXP: return logicals_ok; case INTSXP: return TRUE; case REALSXP: return is_integerish_double(x, tol); case CPLXSXP: return is_integerish_complex(x, tol); } return FALSE; } SEXP c_is_integerish(SEXP x, SEXP tolerance) { return ScalarLogical(isIntegerish(x, REAL(tolerance)[0], FALSE)); } checkmate/src/all_missing.c0000644000176200001440000000503113006331417015427 0ustar liggesusers#include "all_missing.h" Rboolean all_missing_logical(SEXP x) { const int * xp = LOGICAL(x); const int * const xe = xp + xlength(x); for (; xp != xe; xp++) { if (*xp != NA_LOGICAL) return FALSE; } return TRUE; } Rboolean all_missing_integer(SEXP x) { const int * xp = INTEGER(x); const int * const xe = xp + xlength(x); for (; xp != xe; xp++) { if (*xp != NA_INTEGER) return FALSE; } return TRUE; } Rboolean all_missing_double(SEXP x) { const double * xp = REAL(x); const double * const xe = xp + xlength(x); for (; xp != xe; xp++) { if (!ISNAN(*xp)) return FALSE; } return TRUE; } Rboolean all_missing_complex(SEXP x) { const Rcomplex * xp = COMPLEX(x); const Rcomplex * const xe = xp + xlength(x); for (; xp != xe; xp++) { if (!ISNAN((*xp).r) || !ISNAN((*xp).i)) return FALSE; } return TRUE; } Rboolean all_missing_string(SEXP x) { const R_xlen_t nx = xlength(x); for (R_xlen_t i = 0; i < nx; i++) { if (STRING_ELT(x, i) != NA_STRING) return FALSE; } return TRUE; } Rboolean all_missing_atomic(SEXP x) { switch(TYPEOF(x)) { case LGLSXP: return all_missing_logical(x); case INTSXP: return all_missing_integer(x); case REALSXP: return all_missing_double(x); case CPLXSXP: return all_missing_complex(x); case STRSXP: return all_missing_string(x); default: return FALSE; } } Rboolean all_missing_list(SEXP x) { const R_xlen_t nx = xlength(x); for (R_xlen_t i = 0; i < nx; i++) { if (!isNull(VECTOR_ELT(x, i))) return FALSE; } return TRUE; } Rboolean all_missing_frame(SEXP x) { const R_xlen_t nc = xlength(x); for (R_xlen_t i = 0; i < nc; i++) { if (all_missing_atomic(VECTOR_ELT(x, i))) return TRUE; } return FALSE; } Rboolean all_missing(SEXP x) { switch(TYPEOF(x)) { case LGLSXP: return all_missing_logical(x); case INTSXP: return all_missing_integer(x); case REALSXP: return all_missing_double(x); case CPLXSXP: return all_missing_complex(x); case STRSXP: return all_missing_string(x); case NILSXP: return FALSE; case VECSXP: return isFrame(x) ? all_missing_frame(x) : all_missing_list(x); case RAWSXP: return FALSE; default: error("Object of type '%s' not supported", type2char(TYPEOF(x))); } } SEXP c_all_missing(SEXP x) { return ScalarLogical(all_missing(x)); } checkmate/src/checks.h0000644000176200001440000000307613006331417014402 0ustar liggesusers#ifndef CHECKMATE_CHECKS_H_ #define CHECKMATE_CHECKS_H_ #define USE_RINTERNALS #include #include SEXP c_check_array(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_atomic(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_atomic_vector(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_character(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_complex(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_dataframe(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_factor(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_integer(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_integerish(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_list(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_logical(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_matrix(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_named(SEXP, SEXP); SEXP c_check_names(SEXP, SEXP); SEXP c_check_numeric(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_vector(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_count(SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_flag(SEXP, SEXP, SEXP); SEXP c_check_int(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_number(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP c_check_scalar(SEXP, SEXP, SEXP); SEXP c_check_string(SEXP, SEXP, SEXP, SEXP); #endif checkmate/src/qassert.h0000644000176200001440000000043613006331417014621 0ustar liggesusers#ifndef CHECKMATE_QASSERT_H_ #define CHECKMATE_QASSERT_H_ #define USE_RINTERNALS #include #include SEXP c_qassert(SEXP, SEXP, SEXP); SEXP c_qtest(SEXP, SEXP, SEXP, SEXP); SEXP qassert(SEXP, const char *, const char *); Rboolean qtest(SEXP, const char *); #endif checkmate/NAMESPACE0000644000176200001440000001723013006323272013416 0ustar liggesusers# Generated by roxygen2: do not edit by hand S3method(print,AssertCollection) export("%??%") export(allMissing) export(anyInfinite) export(anyMissing) export(anyNaN) export(asCount) export(asInt) export(asInteger) export(assert) export(assertAccess) export(assertArray) export(assertAtomic) export(assertAtomicVector) export(assertCharacter) export(assertChoice) export(assertClass) export(assertComplex) export(assertCount) export(assertDataFrame) export(assertDataTable) export(assertDate) export(assertDirectory) export(assertDirectoryExists) export(assertEnvironment) export(assertFactor) export(assertFile) export(assertFileExists) export(assertFlag) export(assertFunction) export(assertInt) export(assertInteger) export(assertIntegerish) export(assertList) export(assertLogical) export(assertMatrix) export(assertNamed) export(assertNames) export(assertNull) export(assertNumber) export(assertNumeric) export(assertOS) export(assertPathForOutput) export(assertScalar) export(assertScalarNA) export(assertSetEqual) export(assertString) export(assertSubset) export(assertTibble) export(assertVector) export(assert_access) export(assert_array) export(assert_atomic) export(assert_atomic_vector) export(assert_character) export(assert_choice) export(assert_class) export(assert_complex) export(assert_count) export(assert_data_frame) export(assert_data_table) export(assert_date) export(assert_directory) export(assert_directory_exists) export(assert_environment) export(assert_factor) export(assert_file) export(assert_file_exists) export(assert_flag) export(assert_function) export(assert_int) export(assert_integer) export(assert_integerish) export(assert_list) export(assert_logical) export(assert_matrix) export(assert_named) export(assert_names) export(assert_null) export(assert_number) export(assert_numeric) export(assert_os) export(assert_path_for_output) export(assert_scalar) export(assert_scalar_na) export(assert_set_equal) export(assert_string) export(assert_subset) export(assert_tibble) export(assert_vector) export(checkAccess) export(checkArray) export(checkAtomic) export(checkAtomicVector) export(checkCharacter) export(checkChoice) export(checkClass) export(checkComplex) export(checkCount) export(checkDataFrame) export(checkDataTable) export(checkDate) export(checkDirectory) export(checkDirectoryExists) export(checkEnvironment) export(checkFactor) export(checkFile) export(checkFileExists) export(checkFlag) export(checkFunction) export(checkInt) export(checkInteger) export(checkIntegerish) export(checkList) export(checkLogical) export(checkMatrix) export(checkNamed) export(checkNames) export(checkNull) export(checkNumber) export(checkNumeric) export(checkOS) export(checkPathForOutput) export(checkScalar) export(checkScalarNA) export(checkSetEqual) export(checkString) export(checkSubset) export(checkTibble) export(checkVector) export(check_access) export(check_array) export(check_atomic) export(check_atomic_vector) export(check_character) export(check_choice) export(check_class) export(check_complex) export(check_count) export(check_data_frame) export(check_data_table) export(check_date) export(check_directory_exists) export(check_environment) export(check_factor) export(check_file_exists) export(check_flag) export(check_function) export(check_int) export(check_integer) export(check_integerish) export(check_list) export(check_logical) export(check_matrix) export(check_named) export(check_names) export(check_null) export(check_number) export(check_numeric) export(check_os) export(check_path_for_output) export(check_scalar) export(check_scalar_na) export(check_set_equal) export(check_string) export(check_subset) export(check_tibble) export(check_vector) export(expect_access) export(expect_array) export(expect_atomic) export(expect_atomic_vector) export(expect_character) export(expect_choice) export(expect_class) export(expect_complex) export(expect_count) export(expect_data_frame) export(expect_data_table) export(expect_date) export(expect_directory) export(expect_directory_exists) export(expect_environment) export(expect_factor) export(expect_file) export(expect_file_exists) export(expect_flag) export(expect_function) export(expect_int) export(expect_integer) export(expect_integerish) export(expect_list) export(expect_logical) export(expect_matrix) export(expect_names) export(expect_number) export(expect_numeric) export(expect_os) export(expect_path_for_output) export(expect_scalar) export(expect_scalar_na) export(expect_set_equal) export(expect_string) export(expect_subset) export(expect_tibble) export(expect_vector) export(makeAssertCollection) export(makeAssertion) export(makeAssertionFunction) export(makeExpectation) export(makeExpectationFunction) export(makeTest) export(makeTestFunction) export(matchArg) export(qassert) export(qassertr) export(qexpect) export(qexpectr) export(qtest) export(qtestr) export(reportAssertions) export(testAccess) export(testArray) export(testAtomic) export(testAtomicVector) export(testCharacter) export(testChoice) export(testClass) export(testComplex) export(testCount) export(testDataFrame) export(testDataTable) export(testDate) export(testDirectory) export(testDirectoryExists) export(testEnvironment) export(testFactor) export(testFile) export(testFileExists) export(testFlag) export(testFunction) export(testInt) export(testInteger) export(testIntegerish) export(testList) export(testLogical) export(testMatrix) export(testNamed) export(testNames) export(testNull) export(testNumber) export(testNumeric) export(testOS) export(testPathForOutput) export(testScalar) export(testScalarNA) export(testSetEqual) export(testString) export(testSubset) export(testTibble) export(testVector) export(test_access) export(test_array) export(test_atomic) export(test_atomic_vector) export(test_character) export(test_choice) export(test_class) export(test_complex) export(test_count) export(test_data_frame) export(test_data_table) export(test_date) export(test_directory) export(test_directory_exists) export(test_environment) export(test_factor) export(test_file_exists) export(test_flag) export(test_function) export(test_int) export(test_integer) export(test_integerish) export(test_list) export(test_logical) export(test_matrix) export(test_named) export(test_names) export(test_null) export(test_number) export(test_numeric) export(test_os) export(test_path_for_output) export(test_scalar) export(test_scalar_na) export(test_set_equal) export(test_string) export(test_subset) export(test_tibble) export(test_vector) export(vname) export(wf) export(wl) import(backports) importFrom(utils,getFromNamespace) importFrom(utils,head) importFrom(utils,packageVersion) importFrom(utils,tail) useDynLib(checkmate,c_all_missing) useDynLib(checkmate,c_any_infinite) useDynLib(checkmate,c_any_missing) useDynLib(checkmate,c_any_nan) useDynLib(checkmate,c_check_array) useDynLib(checkmate,c_check_atomic) useDynLib(checkmate,c_check_atomic_vector) useDynLib(checkmate,c_check_character) useDynLib(checkmate,c_check_complex) useDynLib(checkmate,c_check_count) useDynLib(checkmate,c_check_dataframe) useDynLib(checkmate,c_check_factor) useDynLib(checkmate,c_check_flag) useDynLib(checkmate,c_check_int) useDynLib(checkmate,c_check_integer) useDynLib(checkmate,c_check_integerish) useDynLib(checkmate,c_check_list) useDynLib(checkmate,c_check_logical) useDynLib(checkmate,c_check_matrix) useDynLib(checkmate,c_check_named) useDynLib(checkmate,c_check_names) useDynLib(checkmate,c_check_number) useDynLib(checkmate,c_check_numeric) useDynLib(checkmate,c_check_scalar) useDynLib(checkmate,c_check_string) useDynLib(checkmate,c_check_vector) useDynLib(checkmate,c_guess_type) useDynLib(checkmate,c_is_integerish) useDynLib(checkmate,c_qassert) useDynLib(checkmate,c_qtest) useDynLib(checkmate,c_which_first) useDynLib(checkmate,c_which_last) checkmate/NEWS.md0000644000176200001440000001642513006323737013310 0ustar liggesusers# Version 1.8.2 (2016-xx-xx) * `*Matrix` and `*Array` now additionally allow to check for integerish storage type via argument "mode". * Functions `*Count`, `*Int`, `*Number`, `*Integer`, `*Integerish` and `*Numeric` do not accept logical values any more. * `checkAtomicVector` is now more restrictive and prohibits a dimension symbol. Thus, a matrix is not considered an atomic vector any more. * Dropped support for AssertCollections in convert functions (`asInt`, `asInteger` and `asCount`). * Added `checkTibble`. # Version 1.8.1 (2016-06-27) * Function `test_file` is longer exported. * `*Function` does not longer lookup functions with `match.fun`. As a result, passing functions via the string of the function name stopped working. * In `qassert` using `f` as first char in a rule now specifies factor (before: function). # Version 1.8.0 (2016-06-06) * Most functions now support the handling of default arguments encoded as `NULL` via argument `null.ok`. * Functions `*File` and `*Directory` are deprecated due to name clashes and will be removed in a future version. Please use `*FileExists` or `*DirectoryExists` instead. * New helper function `matchArg` to provide a simple an easy way for partial argument matching in combination with an AssertCollection. * Added alias functions for all check functions (`check_*`) to provide support for the underscore programming style in `assert()`. # Version 1.7.4 (2016-04-08) * Compatibility with the upcoming testthat version. * `expect_` functions now return the checked object invisibly. * Changed default of argument `.var.name` for assertions and `label` for expectations: They now default to the return value of the exported function `vname` (instead of missing which confuses some linters). * Fixed error message in convert functions: Variable name was not properly looked up by the heuristic. * Fixed a bug in `qassertr` and `qtestr` where the error message was not properly generated if multiple rules were provided. * New argument `depth` for `qtestr` to control the recursion depth while checking nested lists. # Version 1.7.3 (2016-03-10) * Added `checkDate()`. * Argument `.var.name` of assert functions now has \code{NULL} as default value (instead of missing). * Fixed a bug in `*OS` functions. * Fixed a bug in `*Directory` functions. * New argument `extension` for the `*File` family of functions. # Version 1.7.2 (2016-02-25) * Added `checkOS()`. * Argument `fixed` for `*Character` functions now accepts a string instead of a boolean value and thus can directly be used for a substring search. * New arguments `min.chars`, `pattern`, `fixed` and `ignore.case` for the `*String` family of functions. * Exported helper functions `wf` (which.first) and `wl` (which.last). * Now importing the new backports package for functions `lengths()` and `dir.exists`. # Version 1.7.1 (2016-02-02) * Fixed a segfault while checking an upper bound in qassert/qtest. * Some minor speedups # Version 1.7.0 (2016-01-23) * Added alias functions for all functions to support the underscore style, e.g. `assert_numeric` is the new alias for `assertNumeric` and `test_matrix` is the alias for `test_matrix`. * All assert functions now invisibly return the tested object instead of `TRUE` and thus can be used with magrittr pipes. * Improved speed for most functions by reducing the .Call overhead (Thanks to Hadley Wickham). * Added `*DataTable` functions to properly test primary and secondary keys of data tables. * Removed `*Percentage` family of functions. * Exported functions `makeAssertion`, `makeTest` and `makeExpectation` to assist expanding the package with user-generated checks. * Added functions `makeAssertionFunction`, `makeTestFunction` and `makeExpectationFunction` to automatically create the respective functions based on a provided check function. # Version 1.6.3 (2015-10-23) * Assertions can now be collected (via `makeAssertCollection()`) and reported (via `reportAssertions()`). * `qassert()` can now perform bound checks on strings. * The default for the parameter "ordered" of the `*SetEqual` functions is now set to FALSE, as described in the documentation. # Version 1.6.2 (2015-07-26) * Fixed a compile-time warning. * checkmate does not import `testthat` anymore in order to speed up package loading times and to keep the dependencies at a minimum. The `expect_*` family of functions can still be used, the namespace will be loaded on demand. # Version 1.6.1 (2015-07-16) * New family of functions: `expect_*` is intended to be used in combination with testthat. But note that functions `expect_null()` and `expect_named()` are not provided to avoid name clashes with testthat. * Added `qexpect()` and `qexpectr()`. * Added argument `all.missing` for checks of matricies and data frames. * Added `anyNaN()`. * Clarified documentation for `assert()` and `allMissing()`. * Fixed a bug where bound checks were performed on missing values. * Fixed a bug where missingness was not correctly detected in data frames. # Version 1.6.0 (2015-06-19) * Started to support long vectors. * Added a short vignette. * Improved documentation. * New argument "combine" for `assert()` to allow combining check functions with an AND instead of an OR. # Version 1.5.3 (2015-05-13) * Fixed a bug regarding the number of rows in zero-column data frames. * Fixed a bug where the type of lists with dimension attribute where reported as "array" or "matrix". * Family *Array: new arguments "min.d" and "max.d". * Family *Array and *Matrix: Argument "mode" now additionally accepts strings "list" and "atomic". # Version 1.5.2 (2015-03-19) * Fixed: `(assert|check|test)Character(NA_character_, min.chars = 1)` does not eval to TRUE anymore. * New arguments for `*Factor` functions: `(n|min|max).levels`. * Improved error messages for type and length checks. * Improved error messages for missing arguments. # Version 1.5.1 (2014-12-13) * Included a workaround for R's nrow and ncol to properly work with data frames. * Fixed a bug handling complex number in checks for integerish values. * Improved documentation. # Version 1.5.0 (2014-10-18) * Added `checkNames()`. * Added `checkPercentage()`. * Added `anyInfinite()`. * Fixed error messages for some dimension checks. * Fixed an error while checking numerics for finiteness. # Version 1.4 (2014-09-03) * Fixed a bug where rownames and colnames of data.frames where not retrieved correctly. * Fixed a bug in `checkVector()` (wrong order of arguments in call to C). * Filesystem access: checks for write and executable rights are now disabled on windows. # Version 1.3 (2014-08-15) * Fixed a bug where logical values passed a check for numerics in `qassert`. * Family `*SetEqual`: new argument "ordered". * `checkPathForOutput`: new argument "overwrite". # Version 1.2 (2014-07-21) * Fixed bug in checkList. * Fixed dimnames check on empty matrices and data frames. * Added `*SetEqual` functions. # Version 1.1 (2014-06-28) * Improved error messages in `assert*` functions. * New argument 'empty.ok' for `*Subset` functions. * `assert()` now returns TRUE invisibly (as documented). * Fixed handling of zero-length arguments in `checkFunction()`. * Fixed error message if duplicated values where found. * Fixed a missing check for row names in `checkMatrix()` and `checkDataFrame()`. # Version 1.0 (2014-06-17) * Initial release on CRAN. checkmate/R/0000755000176200001440000000000013006323713012375 5ustar liggesuserscheckmate/R/checkNumber.R0000644000176200001440000000230712762010266014754 0ustar liggesusers#' Check if an argument is a single numeric value #' #' @templateVar fn Number #' @template x #' @template na-handling #' @template na.ok #' @template bounds #' @param finite [\code{logical(1)}]\cr #' Check for only finite values? Default is \code{FALSE}. #' @template null.ok #' @template checker #' @useDynLib checkmate c_check_number #' @family scalars #' @export #' @examples #' testNumber(1) #' testNumber(1:2) checkNumber = function(x, na.ok = FALSE, lower = -Inf, upper = Inf, finite = FALSE, null.ok = FALSE) { .Call(c_check_number, x, na.ok, lower, upper, finite, null.ok) } #' @export #' @rdname checkNumber check_number = checkNumber #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkNumber assertNumber = makeAssertionFunction(checkNumber, c.fun = "c_check_number") #' @export #' @rdname checkNumber assert_number = assertNumber #' @export #' @include makeTest.R #' @rdname checkNumber testNumber = makeTestFunction(checkNumber, c.fun = "c_check_number") #' @export #' @rdname checkNumber test_number = testNumber #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkNumber expect_number = makeExpectationFunction(checkNumber, c.fun = "c_check_number") checkmate/R/checkAccess.R0000644000176200001440000000360312762010266014725 0ustar liggesusers#' Check file system access rights #' #' @templateVar fn Access #' @template x #' @param access [\code{character(1)}]\cr #' Single string containing possible characters \sQuote{r}, \sQuote{w} and \sQuote{x} to #' force a check for read, write or execute access rights, respectively. #' Write and executable rights are not checked on Windows. #' @template checker #' @family filesystem #' @export #' @examples #' # Is R's home directory readable? #' testAccess(R.home(), "r") #' #' # Is R's home directory writeable? #' testAccess(R.home(), "w") checkAccess = function(x, access = "") { qassert(access, "S1") if (nzchar(access)) { access = match(strsplit(access, "")[[1L]], c("r", "w", "x")) if (anyMissing(access) || anyDuplicated(access) > 0L) stop("Access pattern invalid, allowed are 'r', 'w' and 'x'") if (1L %in% access) { w = wf(file.access(x, 4L) != 0L) if (length(w) > 0L) return(sprintf("'%s' not readable", x[w])) } if (.Platform$OS.type != "windows") { if (2L %in% access) { w = wf(file.access(x, 2L) != 0L) if (length(w) > 0L) return(sprintf("'%s' not writeable", x[w])) } if (3L %in% access) { w = wf(file.access(x, 1L) != 0L) if (length(w) > 0L) return(sprintf("'%s' not executeable", x[w])) } } } return(TRUE) } #' @export #' @rdname checkAccess check_access = checkAccess #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkAccess assertAccess = makeAssertionFunction(checkAccess) #' @export #' @rdname checkAccess assert_access = assertAccess #' @export #' @include makeTest.R #' @rdname checkAccess testAccess = makeTestFunction(checkAccess) #' @export #' @rdname checkAccess test_access = testAccess #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkAccess expect_access = makeExpectationFunction(checkAccess) checkmate/R/checkAtomicVector.R0000644000176200001440000000500012763530347016124 0ustar liggesusers#' Check that an argument is an atomic vector #' #' @description #' An atomic vector is defined slightly different from specifications in #' \code{\link[base]{is.atomic}} and \code{\link[base]{is.vector}}: #' An atomic vector is either \code{logical}, \code{integer}, \code{numeric}, #' \code{complex}, \code{character} or \code{raw} and can have any attributes except a #' dimension attribute (like matrices). #' I.e., a \code{factor} is an atomic vector, but a matrix or \code{NULL} are not. #' In short, this is mostly equivalent to \code{is.atomic(x) && !is.null(x) && is.null(dim(x))}. #' #' @templateVar fn AtomicVector #' @template x #' @param any.missing [\code{logical(1)}]\cr #' Are vectors with missing values allowed? Default is \code{TRUE}. #' @param all.missing [\code{logical(1)}]\cr #' Are vectors with only missing values allowed? Default is \code{TRUE}. #' @param len [\code{integer(1)}]\cr #' Exact expected length of \code{x}. #' @param min.len [\code{integer(1)}]\cr #' Minimal length of \code{x}. #' @param max.len [\code{integer(1)}]\cr #' Maximal length of \code{x}. #' @param unique [\code{logical(1)}]\cr #' Must all values be unique? Default is \code{FALSE}. #' @param names [\code{character(1)}]\cr #' Check for names. See \code{\link{checkNamed}} for possible values. #' Default is \dQuote{any} which performs no check at all. #' @template checker #' @family atomicvector #' @useDynLib checkmate c_check_atomic_vector #' @export #' @examples #' testAtomicVector(letters, min.len = 1L, any.missing = FALSE) checkAtomicVector = function(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL) { .Call(c_check_atomic_vector, x, any.missing, all.missing, len, min.len, max.len, unique, names) } #' @export #' @rdname checkAtomicVector check_atomic_vector = checkAtomicVector #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkAtomicVector assertAtomicVector = makeAssertionFunction(checkAtomicVector, c.fun = "c_check_atomic_vector") #' @export #' @rdname checkAtomicVector assert_atomic_vector = assertAtomicVector #' @export #' @include makeTest.R #' @rdname checkAtomicVector testAtomicVector = makeTestFunction(checkAtomicVector, c.fun = "c_check_atomic_vector") #' @export #' @rdname checkAtomicVector test_atomic_vector = testAtomicVector #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkAtomicVector expect_atomic_vector = makeExpectationFunction(checkAtomicVector, c.fun = "c_check_atomic_vector") checkmate/R/checkCharacter.R0000644000176200001440000000510412762010266015416 0ustar liggesusers#' Check if an argument is a vector of type character #' #' @templateVar fn Character #' @template x #' @template na-handling #' @inheritParams checkVector #' @param pattern [\code{character(1L)}]\cr #' Regular expression as used in \code{\link[base]{grepl}}. #' All elements of \code{x} must comply to this pattern. #' @param fixed [\code{character(1)}]\cr #' Substring to detect in \code{x}. Will be used as \code{pattern} in \code{\link[base]{grepl}} #' with option \code{fixed} set to \code{TRUE}. #' All elements of \code{x} must contain this substring. #' @param ignore.case [\code{logical(1)}]\cr #' See \code{\link[base]{grepl}}. Default is \code{FALSE}. #' @param min.chars [\code{integer(1)}]\cr #' Minimum number of characters in each element of \code{x}. #' @template null.ok #' @template checker #' @family basetypes #' @useDynLib checkmate c_check_character #' @export #' @examples #' testCharacter(letters, min.len = 1, any.missing = FALSE) #' testCharacter(letters, min.chars = 2) #' testCharacter("example", pattern = "xa") checkCharacter = function(x, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) { .Call(c_check_character, x, min.chars, any.missing, all.missing, len, min.len, max.len, unique, names, null.ok) %and% checkCharacterPattern(x, pattern, fixed, ignore.case) } checkCharacterPattern = function(x, pattern = NULL, fixed = NULL, ignore.case = FALSE) { if (!is.null(x)) { if (!is.null(pattern)) { qassert(pattern, "S1") ok = grepl(pattern, x, fixed = FALSE, ignore.case = ignore.case) if(!all(ok)) return(sprintf("Must comply to pattern '%s'", pattern)) } if (!is.null(fixed)) { qassert(fixed, "S1") ok = grepl(fixed, x, fixed = TRUE, ignore.case = ignore.case) if(!all(ok)) return(sprintf("Must contain substring '%s'", fixed)) } } return(TRUE) } #' @export #' @rdname checkCharacter check_character = checkCharacter #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkCharacter assertCharacter = makeAssertionFunction(checkCharacter) #' @export #' @rdname checkCharacter assert_character = assertCharacter #' @export #' @include makeTest.R #' @rdname checkCharacter testCharacter = makeTestFunction(checkCharacter) #' @export #' @rdname checkCharacter test_character = testCharacter #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkCharacter expect_character = makeExpectationFunction(checkCharacter) checkmate/R/matchArg.R0000644000176200001440000000261412762010266014255 0ustar liggesusers#' Partial Argument Matching #' #' @description #' This is an extensions to \code{\link[base]{match.arg}} with support for \code{\link{AssertCollection}}. #' The behaviour is very similar to \code{\link[base]{match.arg}}, except that \code{NULL} is not #' a valid value for \code{x}. #' #' @param x [character]\cr #' User provided argument to match. #' @param choices [character()]\cr #' Candidates to match \code{x} with. #' @param several.ok [logical(1)]\cr #' If \code{TRUE}, multiple matches are allowed, cf. \code{\link[base]{match.arg}}. #' @template add #' @template var.name #' @return Subset of \code{choices}. #' @export #' @examples #' matchArg("k", choices = c("kendall", "pearson")) matchArg = function(x, choices, several.ok = FALSE, .var.name = vname(x), add = NULL) { assertCharacter(choices, min.len = 1L) assertFlag(several.ok) if (several.ok) { if (identical(x, choices)) return(x) assertCharacter(x, min.len = 1L, .var.name = .var.name, add = add) x = choices[pmatch(x, choices, nomatch = 0L, duplicates.ok = TRUE)] assertSubset(x, choices, empty.ok = FALSE, .var.name = .var.name, add = add) } else { if (identical(x, choices)) return(x[1L]) assertCharacter(x, len = 1L, .var.name = .var.name, add = add) x = choices[pmatch(x, choices, nomatch = 0L, duplicates.ok = FALSE)] assertChoice(x, choices, .var.name = .var.name, add = add) } x } checkmate/R/makeExpectation.R0000644000176200001440000000470612762010266015654 0ustar liggesusers#' @title Turn a Check into an Expectation #' #' @description #' \code{makeExpectation} is the internal function used to evaluate the result of a #' check and turn it into an \code{\link[testthat]{expectation}}. #' \code{makeExceptionFunction} can be used to automatically create an expectation #' function based on a check function (see example). #' #' @template x #' @param res [\code{TRUE} | \code{character(1)}]\cr #' The result of a check function: \code{TRUE} for successful checks, #' and an error message as string otherwise. #' @param info [\code{character(1)}]\cr #' See \code{\link[testthat]{expect_that}} #' @param label [\code{character(1)}]\cr #' See \code{\link[testthat]{expect_that}} #' @return \code{makeExpectation} invisibly returns the checked object. #' \code{makeExpectationFunction} returns a \code{function}. #' @export #' @family CustomConstructors #' @include helper.R #' @examples #' # Simple custom check function #' checkFalse = function(x) if (!identical(x, FALSE)) "Must be FALSE" else TRUE #' #' # Create the respective expect function #' expect_false = function(x, info = NULL, label = vname(x)) { #' res = checkFalse(x) #' makeExpectation(x, res, info = info, label = label) #' } #' #' # Alternative: Automatically create such a function #' expect_false = makeExpectationFunction(checkFalse) #' print(expect_false) makeExpectation = function(x, res, info, label) { if (!requireNamespace("testthat", quietly = TRUE)) stop("Package 'testthat' is required for checkmate's 'expect_*' extensions") info = if (is.null(info)) res else sprintf("%s\nAdditional info: %s", res, info) testthat::expect_true(res, info = info, label = sprintf("Check on %s", label)) invisible(x) } #' @rdname makeExpectation #' @template makeFunction #' @export makeExpectationFunction = function(check.fun, c.fun = NULL, env = parent.frame()) { fn.name = if (!is.character(check.fun)) deparse(substitute(check.fun)) else check.fun check.fun = match.fun(check.fun) x = NULL new.fun = function() TRUE formals(new.fun) = c(formals(check.fun), alist(info = NULL, label = vname(x))) tmpl = "{ res = %s(%s); makeExpectation(x, res, info, label) }" if (is.null(c.fun)) { body(new.fun) = parse(text = sprintf(tmpl, fn.name, paste0(names(formals(check.fun)), collapse = ", "))) } else { body(new.fun) = parse(text = sprintf(tmpl, ".Call", paste0(c(c.fun, names(formals(check.fun))), collapse = ", "))) } environment(new.fun) = env return(new.fun) } checkmate/R/coalesce.R0000644000176200001440000000115112762010266014300 0ustar liggesusers#' @title Coalesce operator #' @rdname coalesce #' #' @description #' Returns the left hand side if not missing nor \code{NULL}, and #' the right hand side otherwise. #' #' @param lhs [any]\cr #' Left hand side of the operator. Is returned if not missing or \code{NULL}. #' @param rhs [any]\cr #' Right hand side of the operator. Is returned if \code{lhs} is missing or \code{NULL}. #' @return Either \code{lhs} or \code{rhs}. #' @export #' @examples #' print(NULL %??% 1 %??% 2) #' print(names(iris) %??% letters[seq_len(ncol(iris))]) "%??%" = function(lhs, rhs) { if (missing(lhs) || is.null(lhs)) rhs else lhs } checkmate/R/checkInt.R0000644000176200001440000000207712762010266014262 0ustar liggesusers#' Check if an argument is a single integerish value #' #' @templateVar fn Int #' @template x #' @template na-handling #' @template na.ok #' @template bounds #' @template tol #' @template null.ok #' @template checker #' @family scalars #' @useDynLib checkmate c_check_int #' @export #' @examples #' testInt(1) #' testInt(-1, lower = 0) checkInt = function(x, na.ok = FALSE, lower = -Inf, upper = Inf, tol = sqrt(.Machine$double.eps), null.ok = FALSE) { .Call(c_check_int, x, na.ok, lower, upper, tol, null.ok) } #' @export #' @rdname checkInt check_int = checkInt #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkInt assertInt = makeAssertionFunction(checkInt, c.fun = "c_check_int") #' @export #' @rdname checkInt assert_int = assertInt #' @export #' @include makeTest.R #' @rdname checkInt testInt = makeTestFunction(checkInt, c.fun = "c_check_int") #' @export #' @rdname checkInt test_int = testInt #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkInt expect_int = makeExpectationFunction(checkInt, c.fun = "c_check_int") checkmate/R/checkIntegerish.R0000644000176200001440000000326112762010266015625 0ustar liggesusers#' @title Check if an object is an integerish vector #' #' @description #' An integerish value is defined as value safely convertible to integer. #' This includes integers and numeric values which are close to an integer #' w.r.t. a numeric tolerance. #' #' @templateVar fn Integerish #' @template x #' @template na-handling #' @inheritParams checkInteger #' @inheritParams checkVector #' @template tol #' @template null.ok #' @template checker #' @family basetypes #' @useDynLib checkmate c_check_integerish #' @export #' @examples #' testIntegerish(1L) #' testIntegerish(1.) #' testIntegerish(1:2, lower = 1L, upper = 2L, any.missing = FALSE) checkIntegerish = function(x, tol = sqrt(.Machine$double.eps), lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) { .Call(c_check_integerish, x, tol, lower, upper, any.missing, all.missing, len, min.len, max.len, unique, names, null.ok) } #' @export #' @rdname checkIntegerish check_integerish = checkIntegerish #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkIntegerish assertIntegerish = makeAssertionFunction(checkIntegerish, c.fun = "c_check_integerish") #' @export #' @rdname checkIntegerish assert_integerish = assertIntegerish #' @export #' @include makeTest.R #' @rdname checkIntegerish testIntegerish = makeTestFunction(checkIntegerish, c.fun = "c_check_integerish") #' @export #' @rdname checkIntegerish test_integerish = testIntegerish #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkIntegerish expect_integerish = makeExpectationFunction(checkIntegerish, c.fun = "c_check_integerish") checkmate/R/checkDataTable.R0000644000176200001440000000525713006323271015347 0ustar liggesusers#' Check if an argument is a data table #' #' @templateVar fn DataTable #' @template x #' @inheritParams checkMatrix #' @inheritParams checkList #' @inheritParams checkDataFrame #' @param key [\code{character}]\cr #' Expected primary key(s) of the data table. #' @param index [\code{character}]\cr #' Expected secondary key(s) of the data table. #' @template null.ok #' @template checker #' @family compound #' @export #' @examples #' library(data.table) #' dt = as.data.table(iris) #' setkeyv(dt, "Species") #' setkeyv(dt, "Sepal.Length", physical = FALSE) #' testDataTable(dt) #' testDataTable(dt, key = "Species", index = "Sepal.Length", any.missing = FALSE) checkDataTable = function(x, key = NULL, index = NULL, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) { checkDataFrame(x, types, any.missing, all.missing, min.rows, min.cols, nrows, ncols, row.names, col.names, null.ok) %and% checkDataTableProps(x, key, index) } checkDataTableProps = function(x, key = NULL, index = NULL) { if (!is.null(x)) { if (!requireNamespace("data.table", quietly = TRUE)) stop("Install 'data.table' to perform checks of data tables") if (!data.table::is.data.table(x)) return("Must be a data.table") if (!is.null(key)) { qassert(key, "S") if (!setequal(data.table::key(x) %??% character(0L), key)) return(sprintf("Must have primary keys: %s", paste0(key, collapse = ","))) } if (!is.null(index)) { qassert(index, "S") indices = strsplit(getDataTableIndexFun()(x) %??% "", "__", fixed = TRUE)[[1L]] if (!setequal(indices, index)) return(sprintf("Must have secondary keys (indices): %s", paste0(index, collapse = ","))) } } return(TRUE) } getDataTableIndexFun = function() { if (is.null(checkmate$data.table.index.fun)) checkmate$data.table.index.fun = if (packageVersion("data.table") >= "1.9.7") getFromNamespace("indices", "data.table") else data.table::key2 checkmate$data.table.index.fun } #' @export #' @rdname checkDataTable check_data_table = checkDataTable #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkDataTable assertDataTable = makeAssertionFunction(checkDataTable) #' @export #' @rdname checkDataTable assert_data_table = assertDataTable #' @export #' @include makeTest.R #' @rdname checkDataTable testDataTable = makeTestFunction(checkDataTable) #' @export #' @rdname checkDataTable test_data_table = testDataTable #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkDataTable expect_data_table = makeExpectationFunction(checkDataTable) checkmate/R/checkSetEqual.R0000644000176200001440000000335713006323647015257 0ustar liggesusers#' Check if an argument is equal to a given set #' #' @templateVar fn Subset #' @template x #' @param y [\code{atomic}]\cr #' Set to compare with. #' @param ordered [\code{logical(1)}]\cr #' Check \code{x} to have the same length and order as \code{y}, i.e. #' check using \dQuote{==} while handling \code{NA}s nicely. #' Default is \code{FALSE}. #' @template checker #' @template set #' @family set #' @export #' @examples #' testSetEqual(c("a", "b"), c("a", "b")) #' testSetEqual(1:3, 1:4) #' #' # x is converted before the comparison if necessary #' # note that this is subject to change in a future version #' testSetEqual(factor("a"), "a") #' testSetEqual(1, "1") #' testSetEqual(1, as.integer(1)) checkSetEqual = function(x, y, ordered = FALSE) { qassert(x, "a") qassert(y, "a") qassert(ordered, "B1") if (ordered) { if (length(x) != length(y) || any(xor(is.na(x), is.na(y)) | x != y, na.rm = TRUE)) return(sprintf("Must be equal to {'%s'}", paste0(y, collapse = "','"))) } else { if (any(match(x, y, 0L) == 0L) || any(match(y, x, 0L) == 0L)) return(sprintf("Must be equal to set {'%s'}", paste0(y, collapse = "','"))) } return(TRUE) } #' @export #' @rdname checkSetEqual check_set_equal = checkSetEqual #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkSetEqual assertSetEqual = makeAssertionFunction(checkSetEqual) #' @export #' @rdname checkSetEqual assert_set_equal = assertSetEqual #' @export #' @include makeTest.R #' @rdname checkSetEqual testSetEqual = makeTestFunction(checkSetEqual) #' @export #' @rdname checkSetEqual test_set_equal = testSetEqual #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkSetEqual expect_set_equal = makeExpectationFunction(checkSetEqual) checkmate/R/makeTest.R0000644000176200001440000000354012762010266014303 0ustar liggesusers#' @title Turn a Check into a Test #' #' @description #' \code{makeTest} is the internal function used to evaluate the result of a #' check and throw an exception if necessary. #' This function is currently only a stub and just calls \code{\link[base]{isTRUE}}. #' \code{makeTestFunction} can be used to automatically create an assertion #' function based on a check function (see example). #' #' @param res [\code{TRUE} | \code{character(1)}]\cr #' The result of a check function: \code{TRUE} for successful checks, #' and an error message as string otherwise. #' @return \code{makeTest} returns \code{TRUE} if the check is successful and \code{FALSE} otherwise. #' \code{makeTestFunction} returns a \code{function}. #' @export #' @family CustomConstructors #' @include helper.R #' @examples #' # Simple custom check function #' checkFalse = function(x) if (!identical(x, FALSE)) "Must be FALSE" else TRUE #' #' # Create the respective test function #' testFalse = function(x) { #' res = checkFalse(x) #' makeTest(res) #' } #' #' # Alternative: Automatically create such a function #' testFalse = makeTestFunction(checkFalse) #' print(testFalse) makeTest = function(res) { identical(res, TRUE) } #' @rdname makeTest #' @template makeFunction #' @export makeTestFunction = function(check.fun, c.fun = NULL, env = parent.frame()) { fn.name = if (!is.character(check.fun)) deparse(substitute(check.fun)) else check.fun check.fun = match.fun(check.fun) new.fun = function() TRUE formals(new.fun) = formals(check.fun) tmpl = "{ identical(%s(%s), TRUE) }" if (is.null(c.fun)) { body(new.fun) = parse(text = sprintf(tmpl, fn.name, paste0(names(formals(check.fun)), collapse = ", "))) } else { body(new.fun) = parse(text = sprintf(tmpl, ".Call", paste0(c(c.fun, names(formals(check.fun))), collapse = ", "))) } environment(new.fun) = env return(new.fun) } checkmate/R/checkLogical.R0000644000176200001440000000234612762010266015101 0ustar liggesusers#' Check if an argument is a vector of type logical #' #' @templateVar fn Logical #' @template x #' @template na-handling #' @inheritParams checkVector #' @template null.ok #' @template checker #' @family basetypes #' @useDynLib checkmate c_check_logical #' @export #' @examples #' testLogical(TRUE) #' testLogical(TRUE, min.len = 1) checkLogical = function(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) { .Call(c_check_logical, x, any.missing, all.missing, len, min.len, max.len, unique, names, null.ok) } #' @export #' @rdname checkLogical check_logical = checkLogical #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkLogical assertLogical = makeAssertionFunction(checkLogical, c.fun = "c_check_logical") #' @export #' @rdname checkLogical assert_logical = assertLogical #' @export #' @include makeTest.R #' @rdname checkLogical testLogical = makeTestFunction(checkLogical, c.fun = "c_check_logical") #' @export #' @rdname checkLogical test_logical = testLogical #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkLogical expect_logical = makeExpectationFunction(checkLogical, c.fun = "c_check_logical") checkmate/R/asInteger.R0000644000176200001440000000341412762010266014447 0ustar liggesusers#' Convert an argument to an integer #' #' @description #' \code{asInteger} is intended to be used for vectors while \code{asInt} is #' a specialization for scalar integers and \code{asCount} for scalar #' non-negative integers. #' Convertible are (a) atomic vectors with all elements \code{NA} #' and (b) double vectors with all elements being within \code{tol} #' range of an integer. #' #' @param x [any]\cr #' Object to convert. #' @template na-handling #' @inheritParams checkInteger #' @inheritParams checkVector #' @template tol #' @template var.name #' @return Converted \code{x}. #' @export #' @examples #' asInteger(c(1, 2, 3)) #' asCount(1) #' asInt(1) asInteger = function(x, tol = sqrt(.Machine$double.eps), lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, .var.name = vname(x)) { assertIntegerish(x, tol = tol, lower = lower, upper = upper, any.missing = any.missing, all.missing = all.missing, len = len, min.len = min.len, max.len = max.len, unique = unique, names = names, null.ok = FALSE, .var.name = .var.name) storage.mode(x) = "integer" x } #' @rdname asInteger #' @param positive [\code{logical(1)}]\cr #' Must \code{x} be positive (>= 1)? #' Default is \code{FALSE}. #' @template na.ok #' @export asCount = function(x, na.ok = FALSE, positive = FALSE, tol = sqrt(.Machine$double.eps), .var.name = vname(x)) { assertCount(x, na.ok, positive, tol, .var.name = .var.name) storage.mode(x) = "integer" x } #' @rdname asInteger #' @template bounds #' @export asInt = function(x, na.ok = FALSE, lower = -Inf, upper = Inf, tol = sqrt(.Machine$double.eps), .var.name = vname(x)) { assertInt(x, na.ok, lower, upper, tol, .var.name = .var.name) storage.mode(x) = "integer" x } checkmate/R/makeAssertion.R0000644000176200001440000000520212762010266015330 0ustar liggesusers#' @title Turn a Check into an Assertion #' #' @description #' \code{makeAssertion} is the internal function used to evaluate the result of a #' check and throw an exception if necessary. #' \code{makeAssertionFunction} can be used to automatically create an assertion #' function based on a check function (see example). #' #' @template x #' @param res [\code{TRUE} | \code{character(1)}]\cr #' The result of a check function: \code{TRUE} for successful checks, #' and an error message as string otherwise. #' @param var.name [\code{character(1)}]\cr #' The custom name for \code{x} as passed to any \code{assert*} function. #' Defaults to a heuristic name lookup. #' @param collection [\code{\link{AssertCollection}}]\cr #' If an \code{\link{AssertCollection}} is provided, the error message is stored #' in it. If \code{NULL}, an exception is raised if \code{res} is not #' \code{TRUE}. #' @return \code{makeAssertion} invisibly returns the checked object if the check was successful, #' and an exception is raised (or its message stored in the collection) otherwise. #' \code{makeAssertionFunction} returns a \code{function}. #' @export #' @family CustomConstructors #' @include helper.R #' @examples #' # Simple custom check function #' checkFalse = function(x) if (!identical(x, FALSE)) "Must be FALSE" else TRUE #' #' # Create the respective assert function #' assertFalse = function(x, .var.name = vname(x), add = NULL) { #' res = checkFalse(x) #' makeAssertion(x, res, .var.name, add) #' } #' #' # Alternative: Automatically create such a function #' assertFalse = makeAssertionFunction(checkFalse) #' print(assertFalse) makeAssertion = function(x, res, var.name, collection) { if (!identical(res, TRUE)) { if (is.null(collection)) mstop("Assertion on '%s' failed: %s.", var.name, res) collection$push(sprintf("Variable '%s': %s.", var.name, res)) } return(invisible(x)) } #' @rdname makeAssertion #' @template makeFunction #' @export makeAssertionFunction = function(check.fun, c.fun = NULL, env = parent.frame()) { fn.name = if (!is.character(check.fun)) deparse(substitute(check.fun)) else check.fun check.fun = match.fun(check.fun) x = NULL new.fun = function() TRUE formals(new.fun) = c(formals(check.fun), alist(.var.name = vname(x), add = NULL)) tmpl = "{ res = %s(%s); makeAssertion(x, res, .var.name, add) }" if (is.null(c.fun)) { body(new.fun) = parse(text = sprintf(tmpl, fn.name, paste0(names(formals(check.fun)), collapse = ", "))) } else { body(new.fun) = parse(text = sprintf(tmpl, ".Call", paste0(c(c.fun, names(formals(check.fun))), collapse = ", "))) } environment(new.fun) = env return(new.fun) } checkmate/R/checkComplex.R0000644000176200001440000000232612762010266015134 0ustar liggesusers#' Check if an argument is a vector of type complex #' #' @templateVar fn Complex #' @template x #' @template na-handling #' @inheritParams checkVector #' @template null.ok #' @template checker #' @family basetypes #' @useDynLib checkmate c_check_complex #' @export #' @examples #' testComplex(1) #' testComplex(1+1i) checkComplex = function(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) { .Call(c_check_complex, x, any.missing, all.missing, len, min.len, max.len, unique, names, null.ok) } #' @export #' @rdname checkComplex check_complex = checkComplex #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkComplex assertComplex = makeAssertionFunction(checkComplex, c.fun = "c_check_complex") #' @export #' @rdname checkComplex assert_complex = assertComplex #' @export #' @include makeTest.R #' @rdname checkComplex testComplex = makeTestFunction(checkComplex, c.fun = "c_check_complex") #' @export #' @rdname checkComplex test_complex = testComplex #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkComplex expect_complex = makeExpectationFunction(checkComplex, c.fun = "c_check_complex") checkmate/R/assert.R0000644000176200001440000000440512762010266014030 0ustar liggesusers#' Combine multiple checks into one assertion #' #' @description #' You can call this function with an arbitrary number of of \code{check*} #' functions, i.e. functions provided by this package or your own functions which #' return \code{TRUE} on success and the error message as \code{character(1)} otherwise. #' The resulting assertion is successful, if \code{combine} is #' \dQuote{or} (default) and at least one check evaluates to \code{TRUE} or #' \code{combine} is \dQuote{and} and all checks evaluate to \code{TRUE}. #' Otherwise, \code{assert} throws an informative error message. #' #' @param ... [any]\cr #' List of calls to check functions. #' @param combine [\code{character(1)}]\cr #' \dQuote{or} or \dQuote{and} to combine the check functions with an OR #' or AND, respectively. #' @template var.name #' @return Throws an error if all checks fail and invisibly returns #' \code{TRUE} otherwise. #' @export #' @examples #' x = 1:10 #' assert(checkNull(x), checkInteger(x, any.missing = FALSE)) #' \dontrun{ #' x = 1 #' assert(checkChoice(x, c("a", "b")), checkDataFrame(x)) #' } assert = function(..., combine = "or", .var.name = NULL) { assertChoice(combine, c("or", "and")) dots = match.call(expand.dots = FALSE)$... env = parent.frame() if (combine == "or") { msgs = character(length(dots)) for (i in seq_along(dots)) { val = eval(dots[[i]], envir = env) if (identical(val, TRUE)) return(invisible(TRUE)) msgs[i] = as.character(val) } if (is.null(.var.name)) .var.name = vapply(dots, function(x) as.character(x)[2L], FUN.VALUE = NA_character_) if (length(msgs) > 1L) { msgs = sprintf("%s(%s): %s", vapply(dots, function(x) as.character(x)[1L], FUN.VALUE = NA_character_), .var.name, msgs) msgs = paste0(c("One of the following must apply:", strwrap(msgs, prefix = " * ")), collapse = "\n") mstop("Assertion failed. %s", msgs) } else { mstop("Assertion on '%s' failed. %s.", .var.name, msgs) } } else { for (i in seq_along(dots)) { val = eval(dots[[i]], envir = env) if (!identical(val, TRUE)) { if (is.null(.var.name)) .var.name = as.character(dots[[1L]])[2L] mstop("Assertion on '%s' failed. %s.", .var.name, val) } } } invisible(TRUE) } checkmate/R/vname.R0000644000176200001440000000072512762010266013636 0ustar liggesusers#' @title Lookup a variable name #' @description #' Tries to heuristically determine the variable name of \code{x} in the parent frame #' with a combination of \code{\link[base]{deparse}} and \code{\link[base]{substitute}}. #' Used for checkmate's error messages. #' @param x [ANY]\cr #' Object. #' @return [\code{character(1)}] Variable name. #' @export vname = function(x) { paste0(deparse(substitute(x, parent.frame(1L)), width.cutoff = 500), collapse = "\n") } checkmate/R/checkFileExists.R0000644000176200001440000000502112762010266015577 0ustar liggesusers#' Check existence and access rights of files #' #' @note #' The functions without the suffix \dQuote{exists} are deprecated and will be removed #' from the package in a future version due to name clashes. #' \code{test_file} has been unexported already. #' #' @templateVar fn FileExists #' @template x #' @inheritParams checkAccess #' @param extension [\code{character}]\cr #' Vector of allowed file extensions, matched case insensitive. #' @template checker #' @family filesystem #' @export #' @examples #' # Check if R's COPYING file is readable #' testFileExists(file.path(R.home(), "COPYING"), access = "r") #' #' # Check if R's COPYING file is readable and writable #' testFileExists(file.path(R.home(), "COPYING"), access = "rw") checkFileExists = function(x, access = "", extension = NULL) { if (!qtest(x, "S+")) return("No file provided") w = wf(dir.exists(x)) if (length(w) > 0L) return(sprintf("File expected, but directory in place: '%s'", x[w])) w = wf(!file.exists(x)) if (length(w) > 0L) return(sprintf("File does not exist: '%s'", x[w])) checkAccess(x, access) %and% checkFileExtension(x, extension) } checkFileExtension = function(x, extension = NULL) { if (!is.null(extension)) { qassert(extension, "S+") pos = regexpr("\\.([[:alnum:]]+)$", x) ext = ifelse(pos > -1L, tolower(substring(x, pos + 1L)), "") if (any(ext %nin% tolower(extension))) return(sprintf("File extension must be in {'%s'}", paste0(extension, collapse = "','"))) } return(TRUE) } #' @export #' @rdname checkFileExists check_file_exists = checkFileExists #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkFileExists assertFileExists = makeAssertionFunction(checkFileExists) #' @export #' @rdname checkFileExists assert_file_exists = assertFileExists #' @export #' @include makeTest.R #' @rdname checkFileExists testFileExists = makeTestFunction(checkFileExists) #' @export #' @rdname checkFileExists test_file_exists = testFileExists #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkFileExists expect_file_exists = makeExpectationFunction(checkFileExists) #' @export #' @rdname checkFileExists checkFile = checkFileExists #' @export #' @rdname checkFileExists assertFile = assertFileExists #' @export #' @rdname checkFileExists assert_file = assert_file_exists #' @export #' @rdname checkFileExists testFile = testFileExists ##' @export ##' @rdname checkFileExists ## test_file = test_file_exists #' @export #' @rdname checkFileExists expect_file = expect_file_exists checkmate/R/isIntegerish.R0000644000176200001440000000021112762037177015165 0ustar liggesusers#' @useDynLib checkmate c_is_integerish isIntegerish = function(x, tol = sqrt(.Machine$double.eps)) { .Call(c_is_integerish, x, tol) } checkmate/R/checkCount.R0000644000176200001440000000237312762010266014617 0ustar liggesusers#' Check if an argument is a count #' #' @description #' A count is defined as non-negative integerish value. #' #' @templateVar fn Count #' @template x #' @template na-handling #' @template na.ok #' @param positive [\code{logical(1)}]\cr #' Must \code{x} be positive (>= 1)? #' Default is \code{FALSE}, allowing 0. #' @template tol #' @template null.ok #' @template checker #' @family scalars #' @useDynLib checkmate c_check_count #' @export #' @examples #' testCount(1) #' testCount(-1) checkCount = function(x, na.ok = FALSE, positive = FALSE, tol = sqrt(.Machine$double.eps), null.ok = FALSE) { .Call(c_check_count, x, na.ok, positive, tol, null.ok) } #' @export #' @rdname checkCount check_count = checkCount #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkCount assertCount = makeAssertionFunction(checkCount, c.fun = "c_check_count") #' @export #' @rdname checkCount assert_count = assertCount #' @export #' @include makeTest.R #' @rdname checkCount testCount = makeTestFunction(checkCount, c.fun = "c_check_count") #' @export #' @rdname checkCount test_count = testCount #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkCount expect_count = makeExpectationFunction(checkCount, c.fun = "c_check_count") checkmate/R/checkAtomic.R0000644000176200001440000000237212762010266014742 0ustar liggesusers#' Check that an argument is an atomic vector #' #' @description #' For the definition of \dQuote{atomic}, see \code{\link[base]{is.atomic}}. #' #' @templateVar fn Atmoic #' @template x #' @inheritParams checkVector #' @template checker #' @useDynLib checkmate c_check_atomic #' @export #' @family basetypes #' @family atomicvector #' @examples #' testAtomic(letters, min.len = 1L, any.missing = FALSE) checkAtomic = function(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL) { .Call(c_check_atomic, x, any.missing, all.missing, len, min.len, max.len, unique, names) } #' @export #' @rdname checkAtomic check_atomic = checkAtomic #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkAtomic assertAtomic = makeAssertionFunction(checkAtomic, c.fun = "c_check_atomic") #' @export #' @rdname checkAtomic assert_atomic = assertAtomic #' @export #' @include makeTest.R #' @rdname checkAtomic testAtomic = makeTestFunction(checkAtomic, c.fun = "c_check_atomic") #' @export #' @rdname checkAtomic test_atomic = testAtomic #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkAtomic expect_atomic = makeExpectationFunction(checkAtomic, c.fun = "c_check_atomic") checkmate/R/checkScalar.R0000644000176200001440000000201712762010266014727 0ustar liggesusers#' Check if an argument is a single atomic value #' #' @templateVar fn Scalar #' @template x #' @template na-handling #' @template na.ok #' @template null.ok #' @template checker #' @family scalars #' @useDynLib checkmate c_check_scalar #' @export #' @examples #' testScalar(1) #' testScalar(1:10) checkScalar = function(x, na.ok = FALSE, null.ok = FALSE) { .Call(c_check_scalar, x, na.ok, null.ok) } #' @export #' @rdname checkScalar check_scalar = checkScalar #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkScalar assertScalar = makeAssertionFunction(checkScalar, c.fun = "c_check_scalar") #' @export #' @rdname checkScalar assert_scalar = assertScalar #' @export #' @include makeTest.R #' @rdname checkScalar testScalar = makeTestFunction(checkScalar, c.fun = "c_check_scalar") #' @export #' @rdname checkScalar test_scalar = testScalar #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkScalar expect_scalar = makeExpectationFunction(checkScalar, c.fun = "c_check_scalar") checkmate/R/wfwl.R0000644000176200001440000000157213004124520013475 0ustar liggesusers#' @title Get the index of the first/last TRUE #' #' @description #' A quick C implementation for \dQuote{which.first} (\code{head(which(x), 1)}) and #' \dQuote{which.last} (\code{tail(which(x), 1)}). #' #' @param x [\code{logical}]\cr #' Logical vector. #' @param use.names [\code{logical(1)}]\cr #' If \code{TRUE} and \code{x} is named, the result is also #' named. #' @return [\code{integer(1)} | \code{integer(0)}]. #' Returns the index of the first/last \code{TRUE} value in \code{x} or #' an empty integer vector if none is found. NAs are ignored. #' @useDynLib checkmate c_which_first #' @export #' @examples #' wf(c(FALSE, TRUE)) #' wl(c(FALSE, FALSE)) #' wf(NA) wf = function(x, use.names = TRUE) { .Call(c_which_first, x, use.names) } #' @rdname wf #' @export #' @useDynLib checkmate c_which_last wl = function(x, use.names = TRUE) { .Call(c_which_last, x, use.names) } checkmate/R/checkList.R0000644000176200001440000000447013006323271014435 0ustar liggesusers#' Check if an argument is a list #' #' @templateVar fn List #' @template x #' @inheritParams checkVector #' @param ... [any]\cr #' Additional parameters used in a call of \code{\link{checkVector}}. #' @param types [\code{character}]\cr #' Character vector of class names. Each list element must inherit #' from at least one of the provided types. #' The types \dQuote{logical}, \dQuote{integer}, \dQuote{integerish}, \dQuote{double}, #' \dQuote{numeric}, \dQuote{complex}, \dQuote{character}, \dQuote{factor}, \dQuote{atomic}, \dQuote{vector} #' \dQuote{atomicvector}, \dQuote{array}, \dQuote{matrix}, \dQuote{list}, \dQuote{function}, #' \dQuote{environment} and \dQuote{null} are supported. #' For other types \code{\link[base]{inherits}} is used as a fallback to check \code{x}'s inheritance. #' Defaults to \code{character(0)} (no check). #' @template null.ok #' @template checker #' @family basetypes #' @export #' @useDynLib checkmate c_check_list #' @examples #' testList(list()) #' testList(as.list(iris), types = c("numeric", "factor")) checkList = function(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) { .Call(c_check_list, x, any.missing, all.missing, len, min.len, max.len, unique, names, null.ok) %and% checkListTypes(x, types) } checkListTypes = function(x, types = character(0L)) { if (is.null(x) || length(types) == 0L) return(TRUE) qassert(types, "S") ind = seq_along(x) for (type in types) { f = checkmate$listtypefuns[[type]] %??% function(x) inherits(x, type) ind = ind[!vapply(x[ind], f, FUN.VALUE = NA, USE.NAMES = FALSE)] if (length(ind) == 0L) return(TRUE) } return(sprintf("May only contain the following types: %s", paste0(types, collapse = ","))) } #' @export #' @rdname checkList check_list = checkList #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkList assertList = makeAssertionFunction(checkList) #' @export #' @rdname checkList assert_list = assertList #' @export #' @include makeTest.R #' @rdname checkList testList = makeTestFunction(checkList) #' @export #' @rdname checkList test_list = testList #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkList expect_list = makeExpectationFunction(checkList) checkmate/R/checkSubset.R0000644000176200001440000000312713006323712014765 0ustar liggesusers#' Check if an argument is a subset of a given set #' #' @templateVar fn Subset #' @template x #' @param choices [\code{atomic}]\cr #' Set of possible values. #' @param empty.ok [\code{logical(1)}]\cr #' Treat zero-length \code{x} as subset of any set \code{choices}? #' Default is \code{TRUE}. #' @template checker #' @template set #' @family set #' @export #' @examples #' testSubset(c("a", "z"), letters) #' testSubset("ab", letters) #' testSubset("Species", names(iris)) #' #' # x is converted before the comparison if necessary #' # note that this is subject to change in a future version #' testSubset(factor("a"), "a") #' testSubset(1, "1") #' testSubset(1, as.integer(1)) checkSubset = function(x, choices, empty.ok = TRUE) { qassert(choices, "a+") qassert(empty.ok, "B1") if (!empty.ok && length(x) == 0L) return(sprintf("Must be a subset of {'%s'}, not empty", paste0(choices, collapse = "','"))) if (!is.null(x) && any(x %nin% choices)) return(sprintf("Must be a subset of {'%s'}", paste0(choices, collapse = "','"))) return(TRUE) } #' @export #' @rdname checkSubset check_subset = checkSubset #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkSubset assertSubset = makeAssertionFunction(checkSubset) #' @export #' @rdname checkSubset assert_subset = assertSubset #' @export #' @include makeTest.R #' @rdname checkSubset testSubset = makeTestFunction(checkSubset) #' @export #' @rdname checkSubset test_subset = testSubset #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkSubset expect_subset = makeExpectationFunction(checkSubset) checkmate/R/qassert.R0000644000176200001440000001174212762010266014213 0ustar liggesusers#' @title Quick argument checks on (builtin) R types #' #' @description #' The provided functions parse rules which allow to express some of the most #' frequent argument checks by typing just a few letters. #' #' @param x [any]\cr #' Object the check. #' @param rules [\code{character}]\cr #' Set of rules. See details. #' @template var.name #' @return #' \code{qassert} throws an \code{R} exception if object \code{x} does #' not comply to at least one of the \code{rules} and returns the tested object invisibly #' otherwise. #' \code{qtest} behaves the same way but returns \code{FALSE} if none of the #' \code{rules} comply. #' \code{qexpect} is intended to be inside the unit test framework \code{\link[testthat]{testthat}} and #' returns an \code{\link[testthat]{expectation}}. #' #' @details #' The rule is specified in up to three parts. #' \enumerate{ #' \item{ #' Class and missingness check. #' The first letter is an abbreviation for the class. If it is #' provided uppercase, missing values are prohibited. #' Supported abbreviations: #' \tabular{rl}{ #' \code{[bB]} \tab Bool / logical.\cr #' \code{[iI]} \tab Integer.\cr #' \code{[xX]} \tab Integerish (numeric convertible to integer, see \code{\link{checkIntegerish}}).\cr #' \code{[rR]} \tab Real / double.\cr #' \code{[cC]} \tab Complex.\cr #' \code{[nN]} \tab Numeric (integer or double).\cr #' \code{[sS]} \tab String / character.\cr #' \code{[fF]} \tab Factor\cr #' \code{[aA]} \tab Atomic.\cr #' \code{[vV]} \tab Atomic vector (see \code{\link{checkAtomicVector}}).\cr #' \code{[lL]} \tab List. Missingness is defined as \code{NULL} element.\cr #' \code{[mM]} \tab Matrix.\cr #' \code{[dD]} \tab Data.frame. Missingness is checked recursively on columns.\cr #' \code{[e]} \tab Environment.\cr #' \code{[0]} \tab \code{NULL}.\cr #' \code{[*]} \tab placeholder to allow any type. #' } #' Note that the check for missingness does not distinguish between #' \code{NaN} and \code{NA}. Infinite values are not treated as missing, but #' can be caught using boundary checks (part 3). #' } #' \item{ #' Length definition. This can be one of #' \tabular{rl}{ #' \code{[*]} \tab any length,\cr #' \code{[?]} \tab length of zero or one,\cr #' \code{[+]} \tab length of at least one, or\cr #' \code{[0-9]+} \tab exact length specified as integer. #' } #' Preceding the exact length with one of the comparison operators \code{=}/\code{==}, #' \code{<}, \code{<=}, \code{>=} or \code{>} is also supported. #' } #' \item{ #' Range check as two numbers separated by a comma, enclosed by square brackets #' (endpoint included) or parentheses (endpoint excluded). #' For example, \dQuote{[0, 3)} results in \code{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 \code{[0,]} contains \code{Inf}, while \code{[0,)} does not. #' The same holds for the left (lower) boundary and \code{-Inf}. #' E.g., the rule \dQuote{N1()} checks for a single finite numeric which is not NA, #' while \dQuote{N1[)} allows \code{-Inf}. #' } #' } #' @note #' The functions are inspired by the blog post of Bogumił Kamiński: #' \url{http://rsnippets.blogspot.de/2013/06/testing-function-agruments-in-gnu-r.html}. #' The implementation is mostly written in C to minimize the overhead. #' @seealso \code{\link{qtestr}} and \code{\link{qassertr}} for efficient checks #' of list elements and data frame columns. #' @useDynLib checkmate c_qassert #' @export #' @examples #' # logical of length 1 #' qtest(NA, "b1") #' #' # logical of length 1, NA not allowed #' qtest(NA, "B1") #' #' # logical of length 0 or 1, NA not allowed #' qtest(TRUE, "B?") #' #' # numeric with length > 0 #' qtest(runif(10), "n+") #' #' # integer with length > 0, NAs not allowed, all integers >= 0 and < Inf #' qtest(1:3, "I+[0,)") #' #' # either an emtpy list or a character vector with <=5 elements #' qtest(1, c("l0", "s<=5")) #' #' # data frame with at least one column and no missing value in any column #' qtest(iris, "D+") qassert = function(x, rules, .var.name = vname(x)) { res = .Call(c_qassert, x, rules, FALSE) if (!identical(res, TRUE)) mstop(qmsg(res, .var.name)) invisible(x) } #' @useDynLib checkmate c_qtest #' @rdname qassert #' @export qtest = function(x, rules) { .Call(c_qtest, x, rules, FALSE) } #' @useDynLib checkmate c_qassert #' @template expect #' @rdname qassert #' @include makeExpectation.R #' @export qexpect = function(x, rules, info = NULL, label = vname(x)) { res = .Call(c_qassert, x, rules, FALSE) if (!identical(res, TRUE)) res = qmsg(res, label) makeExpectation(x, res, info = info, label = label) } qmsg = function(msg, vname) { if (length(msg) > 1L) msg = paste0(c("One of the following must apply:", strwrap(msg, prefix = " * ")), collapse = "\n") sprintf("Assertion on '%s' failed. %s.", vname, msg) } checkmate/R/checkDataFrame.R0000644000176200001440000000255412762010266015354 0ustar liggesusers#' Check if an argument is a data frame #' #' @templateVar fn DataFrame #' @template x #' @inheritParams checkMatrix #' @inheritParams checkList #' @template null.ok #' @template checker #' @family compound #' @family basetypes #' @export #' @useDynLib checkmate c_check_dataframe #' @examples #' testDataFrame(iris) #' testDataFrame(iris, types = c("numeric", "factor"), min.rows = 1, col.names = "named") checkDataFrame = function(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) { .Call(c_check_dataframe, x, any.missing, all.missing, min.rows, min.cols, nrows, ncols, row.names, col.names, null.ok) %and% checkListTypes(x, types) } #' @export #' @rdname checkDataFrame check_data_frame = checkDataFrame #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkDataFrame assertDataFrame = makeAssertionFunction(checkDataFrame) #' @export #' @rdname checkDataFrame assert_data_frame = assertDataFrame #' @export #' @include makeTest.R #' @rdname checkDataFrame testDataFrame = makeTestFunction(checkDataFrame) #' @export #' @rdname checkDataFrame test_data_frame = testDataFrame #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkDataFrame expect_data_frame = makeExpectationFunction(checkDataFrame) checkmate/R/checkPathForOutput.R0000644000176200001440000000400012762010266016300 0ustar liggesusers#' @title Check if a path is suited for creating an output file #' #' @description #' Check if a file path can be safely be used to create a file and write to it. #' #' This is checked: #' \itemize{ #' \item{Does \code{dirname(x)} exist?} #' \item{Does no file under path \code{x} exist?} #' \item{Is \code{dirname(x)} writeable?} #' } #' Paths are relative to the current working directory. #' #' @templateVar fn PathForOutput #' @template x #' @param overwrite [\code{logical(1)}]\cr #' If \code{TRUE}, an existing file in place is allowed if it #' it is both readable and writeable. #' Default is \code{FALSE}. #' @template checker #' @family filesystem #' @export #' @examples #' # Can we create a file in the tempdir? #' testPathForOutput(file.path(tempdir(), "process.log")) checkPathForOutput = function(x, overwrite = FALSE) { if (!qtest(x, "S+")) return("No path provided") qassert(overwrite, "B1") x = normalizePath(x, mustWork = FALSE) dn = dirname(x) w = wf(!dir.exists(dn)) if (length(w) > 0L) return(sprintf("Path to file (dirname) does not exist: '%s' of '%s'", dn[w], x[w])) w = which(file.exists(x)) if (length(w) > 0L) { if (overwrite) return(checkAccess(dn, "w") %and% checkAccess(x[w], "rw")) return(sprintf("File at path already exists: '%s'", x[w])) } return(checkAccess(dn, "w")) } #' @export #' @rdname checkPathForOutput check_path_for_output = checkPathForOutput #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkPathForOutput assertPathForOutput = makeAssertionFunction(checkPathForOutput) #' @export #' @rdname checkPathForOutput assert_path_for_output = assertPathForOutput #' @export #' @include makeTest.R #' @rdname checkPathForOutput testPathForOutput = makeTestFunction(checkPathForOutput) #' @export #' @rdname checkPathForOutput test_path_for_output = testPathForOutput #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkPathForOutput expect_path_for_output = makeExpectationFunction(checkPathForOutput) checkmate/R/checkNull.R0000644000176200001440000000151012762010266014431 0ustar liggesusers#' Check if an argument is NULL #' #' @templateVar fn Null #' @template x #' @template checker #' @family basetypes #' @export #' @examples #' testNull(NULL) #' testNull(1) checkNull = function(x) { if (!is.null(x)) return("Must be NULL") return(TRUE) } #' @export #' @rdname checkNull check_null = checkNull #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkNull assertNull = makeAssertionFunction(checkNull) #' @export #' @rdname checkNull assert_null = assertNull #' @export #' @include makeTest.R #' @rdname checkNull testNull = makeTestFunction(checkNull) #' @export #' @rdname checkNull test_null = testNull # This function is already provided by testthat # #' @export # #' @include makeExpectation.R # #' @template expect # #' @rdname checkNull expect_null = makeExpectationFunction(checkNull) checkmate/R/checkFunction.R0000644000176200001440000000501312762010266015306 0ustar liggesusers#' Check if an argument is a function #' #' @templateVar fn Function #' @template x #' @param args [\code{character}]\cr #' Expected formal arguments. Checks that a function has no arguments if #' set to \code{character(0)}. #' Default is \code{NULL} (no check). #' @param ordered [\code{logical(1)}]\cr #' Flag whether the arguments provided in \code{args} must be the first #' \code{length(args)} arguments of the function in the specified order. #' Default is \code{FALSE}. #' @param nargs [\code{integer(1)}]\cr #' Required number of arguments, without \code{...}. #' Default is \code{NULL} (no check). #' @template null.ok #' @template checker #' @family basetypes #' @export #' @examples #' testFunction(mean) #' testFunction(mean, args = "x") checkFunction = function(x, args = NULL, ordered = FALSE, nargs = NULL, null.ok = FALSE) { if (is.null(x)) { if (identical(null.ok, TRUE)) return(TRUE) return("Must be a function, not 'NULL'") } if (!is.function(x)) return(sprintf("Must be a function%s, not '%s'", if (isTRUE(null.ok)) " (or 'NULL')" else "", guessType(x))) if (!is.null(args)) { qassert(args, "S") fargs = names(formals(x)) %??% character(0L) if (length(args) == 0L) { if (length(fargs) > 0L) return("May not have any arguments") return(TRUE) } qassert(ordered, "B1") if (ordered) { if (any(args != head(fargs, length(args)))) { return(sprintf("Must have first formal arguments (ordered): %s", paste0(args, collapse = ","))) } } else { tmp = setdiff(args, fargs) if (length(tmp)) return(sprintf("Must have formal arguments: %s", paste0(tmp, collapse = ","))) } } if (!is.null(nargs)) { nargs = asCount(nargs) fnargs = length(setdiff(names(formals(x)) %??% character(0L), "...")) if (nargs != fnargs) return(sprintf("Must have exactly %i formal arguments, but has %i", nargs, fnargs)) } return(TRUE) } #' @export #' @rdname checkFunction check_function = checkFunction #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkFunction assertFunction = makeAssertionFunction(checkFunction) #' @export #' @rdname checkFunction assert_function = assertFunction #' @export #' @include makeTest.R #' @rdname checkFunction testFunction = makeTestFunction(checkFunction) #' @export #' @rdname checkFunction test_function = testFunction #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkFunction expect_function = makeExpectationFunction(checkFunction) checkmate/R/checkVector.R0000644000176200001440000000440512762010266014767 0ustar liggesusers#' Check if an argument is a vector #' #' @templateVar fn Vector #' @template x #' @param strict [\code{logical(1)}]\cr #' May the vector have additional attributes or perform a #' check for additional attributes like \code{\link[base]{is.vector}}? #' Default is \code{FALSE} which allows e.g. \code{factor}s or \code{data.frame}s #' to be recognized as vectors. #' @param any.missing [\code{logical(1)}]\cr #' Are vectors with missing values allowed? Default is \code{TRUE}. #' @param all.missing [\code{logical(1)}]\cr #' Are vectors with only missing values allowed? Default is \code{TRUE}. #' @param len [\code{integer(1)}]\cr #' Exact expected length of \code{x}. #' @param min.len [\code{integer(1)}]\cr #' Minimal length of \code{x}. #' @param max.len [\code{integer(1)}]\cr #' Maximal length of \code{x}. #' @param unique [\code{logical(1)}]\cr #' Must all values be unique? Default is \code{FALSE}. #' @param names [\code{character(1)}]\cr #' Check for names. See \code{\link{checkNamed}} for possible values. #' Default is \dQuote{any} which performs no check at all. #' Note that you can use \code{\link{checkSubset}} to check for a specific set of names. #' @template null.ok #' @template checker #' @family basetypes #' @family atomicvector #' @useDynLib checkmate c_check_vector #' @export #' @examples #' testVector(letters, min.len = 1L, any.missing = FALSE) checkVector = function(x, strict = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) { .Call(c_check_vector, x, strict, any.missing, all.missing, len, min.len, max.len, unique, names, null.ok) } #' @export #' @rdname checkVector check_vector = checkVector #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkVector assertVector = makeAssertionFunction(checkVector, c.fun = "c_check_vector") #' @export #' @rdname checkVector assert_vector = assertVector #' @export #' @include makeTest.R #' @rdname checkVector testVector = makeTestFunction(checkVector, c.fun = "c_check_vector") #' @export #' @rdname checkVector test_vector = testVector #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkVector expect_vector = makeExpectationFunction(checkVector, c.fun = "c_check_vector") checkmate/R/qassertr.R0000644000176200001440000000454712762010266014402 0ustar liggesusers#' @title Quick recursive arguments checks on lists and data frames #' #' @description #' These functions are the tuned counterparts of \code{\link{qtest}}, #' \code{\link{qassert}} and \code{\link{qexpect}} tailored for recursive #' checks of list elements or data frame columns. #' #' @param x [\code{list} or \code{data.frame}]\cr #' List or data frame to check for compliance with at least one of \code{rules}. #' See details of \code{\link{qtest}} for rule explanation. #' @param rules [\code{character}]\cr #' Set of rules. See \code{\link{qtest}} #' @template var.name #' @return See \code{\link{qassert}}. #' @seealso \code{\link{qtest}}, \code{\link{qassert}} #' @useDynLib checkmate c_qassert #' @export #' @examples #' # All list elements are integers with length >= 1? #' qtestr(as.list(1:10), "i+") #' #' # All list elements (i.e. data frame columns) are numeric? #' qtestr(iris, "n") #' #' # All list elements are numeric, w/o NAs? #' qtestr(list(a = 1:3, b = rnorm(1), c = letters), "N+") #' #' # All list elements are numeric OR character #' qtestr(list(a = 1:3, b = rnorm(1), c = letters), c("N+", "S+")) qassertr = function(x, rules, .var.name = vname(x)) { res = .Call(c_qassert, x, rules, TRUE, 1L) if (!identical(res, TRUE)) mstop(qrmsg(x, res, .var.name)) invisible(x) } #' @rdname qassertr #' @param depth [\code{integer(1)}]\cr #' Maximum recursion depth. Defaults to \dQuote{1} to directly check list elements or #' data frame columns. Set to a higher value to check lists of lists of elements. #' @useDynLib checkmate c_qtest #' @export qtestr = function(x, rules, depth = 1L) { .Call(c_qtest, x, rules, TRUE, depth) } #' @rdname qassertr #' @template expect #' @include makeExpectation.R #' @useDynLib checkmate c_qassert #' @export qexpectr = function(x, rules, info = NULL, label = vname(x)) { res = .Call(c_qassert, x, rules, TRUE, 1L) if (!identical(res, TRUE)) res = qrmsg(x, res, label) makeExpectation(x, res, info = info, label = label) } qrmsg = function(x, msg, var.name) { pos = attr(msg, "pos") if (testNamed(x)) { item = sprintf(", element '%s' (%i),", names(x)[pos], pos) } else { item = sprintf(", element %i,", pos) } if (length(msg) > 1L) msg = paste0(c("One of the following must apply:", strwrap(msg, prefix = " * ")), collapse = "\n") sprintf("Assertion on '%s'%s failed. %s.", var.name, item, msg) } checkmate/R/checkNamed.R0000644000176200001440000000313312762010266014546 0ustar liggesusers#' Check if an argument is named #' #' @templateVar fn Named #' @template x #' @param type [character(1)]\cr #' Select the check(s) to perform. #' \dQuote{unnamed} checks \code{x} to be unnamed. #' \dQuote{named} (default) checks \code{x} to be named which excludes names to be \code{NA} or empty (\code{""}). #' \dQuote{unique} additionally tests for non-duplicated names. #' \dQuote{strict} checks for unique names which comply to R's variable name restrictions. #' Note that for zero-length \code{x} every name check evaluates to \code{TRUE}. #' @template checker #' @note #' These function are deprecated and will be removed in a future version. #' Please use \code{\link{checkNames}} instead. #' @useDynLib checkmate c_check_named #' @family attributes #' @export #' @examples #' x = 1:3 #' testNamed(x, "unnamed") #' names(x) = letters[1:3] #' testNamed(x, "unique") checkNamed = function(x, type = "named") { .Call(c_check_named, x, type) } #' @export #' @rdname checkNamed check_named = checkNamed #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkNamed assertNamed = makeAssertionFunction(checkNamed, c.fun = "c_check_named") #' @export #' @rdname checkNamed assert_named = assertNamed #' @export #' @include makeTest.R #' @rdname checkNamed testNamed = makeTestFunction(checkNamed, c.fun = "c_check_named") #' @export #' @rdname checkNamed test_named = testNamed # This function is already provided by testthat # #' @export # #' @include makeExpectation.R # #' @template expect # #' @rdname checkNamed expect_named = makeExpectationFunction(checkNamed, c.fun = "c_check_named") checkmate/R/checkFlag.R0000644000176200001440000000201312762010266014367 0ustar liggesusers#' Check if an argument is a flag #' #' @description #' A flag is defined as single logical value. #' #' @templateVar fn Flag #' @template x #' @template na-handling #' @template na.ok #' @template null.ok #' @template checker #' @family scalars #' @useDynLib checkmate c_check_flag #' @export #' @examples #' testFlag(TRUE) #' testFlag(1) checkFlag = function(x, na.ok = FALSE, null.ok = FALSE) { .Call(c_check_flag, x, na.ok, null.ok) } #' @export #' @rdname checkFlag check_flag = checkFlag #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkFlag assertFlag = makeAssertionFunction(checkFlag, c.fun = "c_check_flag") #' @export #' @rdname checkFlag assert_flag = assertFlag #' @export #' @include makeTest.R #' @rdname checkFlag testFlag = makeTestFunction(checkFlag, c.fun = "c_check_flag") #' @export #' @rdname checkFlag test_flag = testFlag #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkFlag expect_flag = makeExpectationFunction(checkFlag, c.fun = "c_check_flag") checkmate/R/checkDirectoryExists.R0000644000176200001440000000405512762010266016672 0ustar liggesusers#' Check for existence and access rights of directories #' #' @note #' The functions without the suffix \dQuote{exists} are deprecated and will be removed #' from the package in a future version due to name clashes. #' #' @templateVar fn DirectoryExists #' @template x #' @inheritParams checkAccess #' @inheritParams checkFile #' @template checker #' @family filesystem #' @export #' @examples #' # Is R's home directory readable? #' testDirectory(R.home(), "r") #' #' # Is R's home directory readable and writable? #' testDirectory(R.home(), "rw") checkDirectoryExists = function(x, access = "") { if (!qtest(x, "S+")) return("No directory provided") w = wf(!file.exists(x)) if (length(w) > 0L) return(sprintf("Directory '%s' does not exists", x[w])) w = wf(!dir.exists(x)) if (length(w) > 0L) return(sprintf("Directory expected, but file in place: '%s'", x[w])) checkAccess(x, access) } #' @export #' @rdname checkDirectoryExists check_directory_exists = checkDirectoryExists #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkDirectoryExists assertDirectoryExists = makeAssertionFunction(checkDirectoryExists) #' @export #' @rdname checkDirectoryExists assert_directory_exists = assertDirectoryExists #' @export #' @include makeTest.R #' @rdname checkDirectoryExists testDirectoryExists = makeTestFunction(checkDirectoryExists) #' @export #' @rdname checkDirectoryExists test_directory_exists = testDirectoryExists #' @export #' @rdname checkDirectoryExists expect_directory_exists = makeExpectationFunction(checkDirectoryExists) #' @export #' @rdname checkDirectoryExists checkDirectory = checkDirectoryExists #' @export #' @rdname checkDirectoryExists assertDirectory = assertDirectoryExists #' @export #' @rdname checkDirectoryExists assert_directory = assert_directory_exists #' @export #' @rdname checkDirectoryExists testDirectory = testDirectoryExists #' @export #' @rdname checkDirectoryExists test_directory = test_directory_exists #' @export #' @rdname checkDirectoryExists expect_directory = expect_directory_exists checkmate/R/checkDate.R0000644000176200001440000000441712762010266014405 0ustar liggesusers#' Check that an argument is a Date #' #' @description #' Checks that an object is of class \code{\link[base]{Date}}. #' #' #' @templateVar fn Atmoic #' @template x #' @param lower [\code{\link[base]{Date}}]\cr #' All dates in \code{x} must be after this date. Comparison is done via \code{\link[base]{Ops.Date}}. #' @param upper [\code{\link[base]{Date}}]\cr #' All dates in \code{x} must be before this date. Comparison is done via \code{\link[base]{Ops.Date}}. #' @template null.ok #' @inheritParams checkVector #' @template checker #' @family basetypes #' @export checkDate = function(x, lower = NULL, upper = NULL, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, null.ok = FALSE) { if (is.null(x)) { if (isTRUE(null.ok)) return(TRUE) return("Must be of class 'Date', not 'NULL'") } if (!inherits(x, "Date")) return(sprintf("Must be of class 'Date'%s, not '%s'", if (isTRUE(null.ok)) " (or 'NULL')" else "", guessType(x))) checkInteger(as.integer(x), any.missing = any.missing, all.missing = all.missing, len = len, min.len = min.len, max.len = max.len, unique = unique) %and% checkDateBounds(x, lower, upper) } checkDateBounds = function(x, lower, upper) { if (!is.null(lower)) { lower = as.Date(lower, origin = "1970-01-01") if (length(lower) != 1L || is.na(lower)) stop("Argument 'lower' must be a single (non-missing) date") if (any(x < lower)) return(sprintf("Date must be >= %s", lower)) } if (!is.null(upper)) { upper = as.Date(upper, origin = "1970-01-01") if (length(upper) != 1L || is.na(upper)) stop("Argument 'upper' must be a single (non-missing) date") if (any(x > upper)) return(sprintf("Date must be <= %s", upper)) } return(TRUE) } #' @export #' @rdname checkDate check_date = checkDate #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkDate assertDate = makeAssertionFunction(checkDate) #' @export #' @rdname checkDate assert_date = assertDate #' @export #' @include makeTest.R #' @rdname checkDate testDate = makeTestFunction(checkDate) #' @export #' @rdname checkDate test_date = testDate #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkDate expect_date = makeExpectationFunction(checkDate) checkmate/R/checkString.R0000644000176200001440000000226012762010266014770 0ustar liggesusers#' Check if an argument is a string #' #' @description #' A string is defined as a scalar character vector. #' #' @templateVar fn String #' @template x #' @template na-handling #' @template na.ok #' @inheritParams checkCharacter #' @template null.ok #' @template checker #' @family scalars #' @export #' @useDynLib checkmate c_check_string #' @examples #' testString("a") #' testString(letters) checkString = function(x, na.ok = FALSE, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, null.ok = FALSE) { .Call(c_check_string, x, na.ok, min.chars, null.ok) %and% checkCharacterPattern(x, pattern, fixed, ignore.case) } #' @export #' @rdname checkString check_string = checkString #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkString assertString = makeAssertionFunction(checkString) #' @export #' @rdname checkString assert_string = assertString #' @export #' @include makeTest.R #' @rdname checkString testString = makeTestFunction(checkString) #' @export #' @rdname checkString test_string = testString #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkString expect_string = makeExpectationFunction(checkString) checkmate/R/checkClass.R0000644000176200001440000000372312762010266014574 0ustar liggesusers#' Check the class membership of an argument #' #' @templateVar fn Class #' @template x #' @param classes [\code{character}]\cr #' Class names to check for inheritance with \code{\link[base]{inherits}}. #' @param ordered [\code{logical(1)}]\cr #' Expect \code{x} to be specialized in provided order. #' Default is \code{FALSE}. #' @template checker #' @family attributes #' @export #' @examples #' # Create an object with classes "foo" and "bar" #' x = 1 #' class(x) = c("foo", "bar") #' #' # is x of class "foo"? #' testClass(x, "foo") #' #' # is x of class "foo" and "bar"? #' testClass(x, c("foo", "bar")) #' #' # is x of class "foo" or "bar"? #' \dontrun{ #' assert( #' checkClass(x, "foo"), #' checkClass(x, "bar") #' ) #' } #' # is x most specialized as "bar"? #' testClass(x, "bar", ordered = TRUE) checkClass = function(x, classes, ordered = FALSE) { qassert(classes, "S") qassert(ordered, "B1") ord = inherits(x, classes, TRUE) w = wf(ord == 0L) if (length(w) > 0L) { cl = class(x) return(sprintf("Must have class '%s', but has class%s '%s'", classes[w], if (length(cl) > 1L) "es" else "", paste0(cl, collapse = "','"))) } if (ordered) { w = wf(ord != seq_along(ord)) if (length(w) > 0L) { cl = class(x) return(sprintf("Must have class '%s' in position %i, but has class%s '%s'", classes[w], w, if (length(cl) > 1L) "es" else "", paste0(cl, collapse = "','"))) } } return(TRUE) } #' @export #' @rdname checkClass check_class = checkClass #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkClass assertClass = makeAssertionFunction(checkClass) #' @export #' @rdname checkClass assert_class = assertClass #' @export #' @include makeTest.R #' @rdname checkClass testClass = makeTestFunction(checkClass) #' @export #' @rdname checkClass test_class = testClass #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkClass expect_class = makeExpectationFunction(checkClass) checkmate/R/helper.R0000644000176200001440000000104513006323355014001 0ustar liggesusersmstop = function(msg, ...) { stop(simpleError(message = sprintf(msg, ...), call = sys.call(1L))) } "%and%" = function(lhs, rhs) { if (identical(lhs, TRUE)) rhs else lhs } "%nin%" = function(x, y) { !match(x, y, nomatch = 0L) } convertCamelCase = function(x) { tolower(gsub("((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))", "_\\1", x, perl = TRUE)) } #' @useDynLib checkmate c_guess_type guessType = function(x) { .Call(c_guess_type, x) } isSameType = function(x, y) { identical(typeof(x), typeof(y)) || (is.numeric(x) && is.numeric(y)) } checkmate/R/checkNames.R0000644000176200001440000000643212762010266014572 0ustar liggesusers#' Check names to comply to specific rules #' #' @description #' Similar to \code{\link{checkNamed}} but you can pass the names directly. #' #' @templateVar fn Named #' @param x [\code{character} || \code{NULL}]\cr #' Names to check using rules defined via \code{type}. #' @param type [character(1)]\cr #' Type of formal check(s) to perform on the names. #' \dQuote{unnamed} checks \code{x} to be \code{NULL}. #' \dQuote{named} (default) checks \code{x} for regular names which excludes names to be \code{NA} or empty (\code{""}). #' \dQuote{unique} additionally tests for non-duplicated names. #' \dQuote{strict} checks for unique names which comply to R's variable name restrictions. #' Note that for zero-length \code{x} all these name checks evaluate to \code{TRUE}. #' @param permutation.of [\code{character}]\cr #' Names provided in \code{x} must be a permutation of the set \code{permutation.of}. #' Duplicated names in \code{permutation.of} are stripped out and duplicated names in \code{x} #' thus lead to a failed check. #' Use this argument instead of \code{identical.to} if the order of the names is not relevant. #' @param subset.of [\code{character}]\cr #' Names provided in \code{x} must be subset of the set \code{subset.of}. #' Use this argument if duplicated names are okay. #' @param identical.to [\code{character}]\cr #' Names provided in \code{x} must be identical to the vector \code{identical.to}. #' Use this argument instead of \code{permutation.of} if the order of the names is relevant. #' @template checker #' @useDynLib checkmate c_check_names #' @family attributes #' @export #' @examples #' x = 1:3 #' testNames(x, "unnamed") #' names(x) = letters[1:3] #' testNames(x, "unique") #' #' cn = c("Species", "Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width") #' assertNames(names(iris), permutation.of = cn) checkNames = function(x, type = "named", permutation.of = NULL, subset.of = NULL, identical.to = NULL) { .Call(c_check_names, x, type) %and% checkNamesCmp(x, permutation.of, subset.of, identical.to) } checkNamesCmp = function(x, permutation.of, subset.of, identical.to) { if (!is.null(permutation.of)) { permutation.of = unique(qassert(permutation.of, "S")) if (length(x) != length(permutation.of) || !setequal(x, permutation.of)) return(sprintf("Must be a permutation of set {%s}", paste0(permutation.of, collapse = ","))) } if (!is.null(subset.of)) { qassert(subset.of, "S") if (anyMissing(match(x, subset.of))) return(sprintf("Must be a subset of set {%s}", paste0(subset.of, collapse = ","))) } if (!is.null(identical.to)) { qassert(identical.to, "S") if (!identical(x, identical.to)) return(sprintf("Must be a identical to (%s)", paste0(identical.to, collapse = ","))) } return(TRUE) } #' @export #' @rdname checkNames check_names = checkNames #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkNames assertNames = makeAssertionFunction(checkNames) #' @export #' @rdname checkNames assert_names = assertNames #' @export #' @include makeTest.R #' @rdname checkNames testNames = makeTestFunction(checkNames) #' @export #' @rdname checkNames test_names = testNames #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkNames expect_names = makeExpectationFunction(checkNames) checkmate/R/allMissing.R0000644000176200001440000000054012762010266014625 0ustar liggesusers#' @rdname anyMissing #' @useDynLib checkmate c_all_missing #' @export #' @examples #' allMissing(1:2) #' allMissing(c(1, NA)) #' allMissing(c(NA, NA)) #' x = data.frame(a = 1:2, b = NA) #' # Note how allMissing combines the results for data frames: #' allMissing(x) #' all(sapply(x, allMissing)) allMissing = function(x) { .Call(c_all_missing, x) } checkmate/R/checkTibble.R0000644000176200001440000000275712762010266014736 0ustar liggesusers#' Check if an argument is a tibble #' #' @templateVar fn Tibble #' @template x #' @inheritParams checkMatrix #' @inheritParams checkList #' @inheritParams checkDataFrame #' @template null.ok #' @template checker #' @family compound #' @export #' @examples #' library(tibble) #' x = as_tibble(iris) #' testTibble(x) #' testTibble(x, nrow = 150, any.missing = FALSE) checkTibble = function(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) { if (is.null(x)) { if (identical(null.ok, TRUE)) return(TRUE) return("Must be a tibble, not 'NULL'") } if (!inherits(x, "tbl_df")) return(paste0("Must be a tibble", if (isTRUE(null.ok)) " (or 'NULL')" else "", sprintf(", not %s", guessType(x)))) checkDataFrame(x, types, any.missing, all.missing, min.rows, min.cols, nrows, ncols, row.names, col.names, null.ok) } #' @export #' @rdname checkTibble check_tibble = checkTibble #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkTibble assertTibble = makeAssertionFunction(checkTibble) #' @export #' @rdname checkTibble assert_tibble = assertTibble #' @export #' @include makeTest.R #' @rdname checkTibble testTibble = makeTestFunction(checkTibble) #' @export #' @rdname checkTibble test_tibble = testTibble #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkTibble expect_tibble = makeExpectationFunction(checkTibble) checkmate/R/checkChoice.R0000644000176200001440000000233413006323604014711 0ustar liggesusers#' Check if an object is an element of a given set #' #' @templateVar fn Choice #' @template x #' @param choices [\code{atomic}]\cr #' Set of possible values. #' @template checker #' @template set #' @family set #' @export #' @examples #' testChoice("x", letters) #' #' # x is converted before the comparison if necessary #' # note that this is subject to change in a future version #' testChoice(factor("a"), "a") #' testChoice(1, "1") #' testChoice(1, as.integer(1)) checkChoice = function(x, choices) { qassert(choices, "a") if (!qtest(x, "a1") || x %nin% choices) return(sprintf("Must be element of set {'%s'}", paste0(unique(choices), collapse = "','"))) return(TRUE) } #' @export #' @rdname checkChoice check_choice = checkChoice #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkChoice assertChoice = makeAssertionFunction(checkChoice) #' @export #' @rdname checkChoice assert_choice = assertChoice #' @export #' @include makeTest.R #' @rdname checkChoice testChoice = makeTestFunction(checkChoice) #' @export #' @rdname checkChoice test_choice = testChoice #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkChoice expect_choice = makeExpectationFunction(checkChoice) checkmate/R/checkMatrix.R0000644000176200001440000000441612762010266014773 0ustar liggesusers#' Check if an argument is a matrix #' #' @templateVar fn Matrix #' @template x #' @template mode #' @param any.missing [\code{logical(1)}]\cr #' Are missing values allowed? Default is \code{TRUE}. #' @param all.missing [\code{logical(1)}]\cr #' Are matrices with only missing values allowed? Default is \code{TRUE}. #' @param min.rows [\code{integer(1)}]\cr #' Minimum number of rows. #' @param min.cols [\code{integer(1)}]\cr #' Minimum number of columns. #' @param nrows [\code{integer(1)}]\cr #' Exact number of rows. #' @param ncols [\code{integer(1)}]\cr #' Exact number of columns. #' @param row.names [\code{character(1)}]\cr #' Check for row names. Default is \dQuote{NULL} (no check). #' See \code{\link{checkNamed}} for possible values. #' Note that you can use \code{\link{checkSubset}} to check for a specific set of names. #' @param col.names [\code{character(1)}]\cr #' Check for column names. Default is \dQuote{NULL} (no check). #' See \code{\link{checkNamed}} for possible values. #' Note that you can use \code{\link{checkSubset}} to test for a specific set of names. #' @template null.ok #' @template checker #' @family basetypes #' @family compound #' @useDynLib checkmate c_check_matrix #' @export #' @examples #' x = matrix(1:9, 3) #' colnames(x) = letters[1:3] #' testMatrix(x, nrows = 3, min.cols = 1, col.names = "named") checkMatrix = function(x, mode = NULL, any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) { .Call(c_check_matrix, x, mode, any.missing, all.missing, min.rows, min.cols, nrows, ncols, row.names, col.names, null.ok) } #' @export #' @rdname checkMatrix check_matrix = checkMatrix #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkMatrix assertMatrix = makeAssertionFunction(checkMatrix, c.fun = "c_check_matrix") #' @export #' @rdname checkMatrix assert_matrix = assertMatrix #' @export #' @include makeTest.R #' @rdname checkMatrix testMatrix = makeTestFunction(checkMatrix, c.fun = "c_check_matrix") #' @export #' @rdname checkMatrix test_matrix = testMatrix #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkMatrix expect_matrix = makeExpectationFunction(checkMatrix, c.fun = "c_check_matrix") checkmate/R/checkOS.R0000644000176200001440000000230313006323271014034 0ustar liggesusers#' Check the operating system #' #' @templateVar fn OS #' @param os [\code{character(1)}]\cr #' Check the operating system to be in a set with possible elements \dQuote{windows}, #' \dQuote{mac}, \dQuote{linux} and \dQuote{solaris}. #' @template checker #' @export #' @examples #' testOS("linux") checkOS = function(os) { ok = match.arg(os, c("windows", "mac", "linux", "solaris"), several.ok = TRUE) if (checkmate$os %nin% ok) return(sprintf("OS must be %s", paste0(ok, collapse = " or "))) return(TRUE) } #' @export #' @rdname checkOS check_os = checkOS #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkOS assertOS = function(os, add = NULL, .var.name = NULL) { res = checkOS(os) makeAssertion(os, res, .var.name %??% "Operating System", add) } #' @export #' @rdname checkOS assert_os = assertOS #' @export #' @include makeTest.R #' @rdname checkOS testOS = makeTestFunction(checkOS) #' @export #' @rdname checkOS test_os = testOS #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkOS expect_os = function(os, info = NULL, label = NULL) { res = checkOS(os) makeExpectation(checkmate$os, res, info, label = label %??% "Operating System") } checkmate/R/checkInteger.R0000644000176200001440000000256312762010266015125 0ustar liggesusers#' Check if an argument is vector of type integer #' #' @templateVar fn Integer #' @template x #' @template na-handling #' @inheritParams checkVector #' @template bounds #' @template null.ok #' @template checker #' @family basetypes #' @seealso \code{\link{asInteger}} #' @useDynLib checkmate c_check_integer #' @export #' @examples #' testInteger(1L) #' testInteger(1.) #' testInteger(1:2, lower = 1, upper = 2, any.missing = FALSE) checkInteger = function(x, lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) { .Call(c_check_integer, x, lower, upper, any.missing, all.missing, len, min.len, max.len, unique, names, null.ok) } #' @export #' @rdname checkInteger check_integer = checkInteger #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkInteger assertInteger = makeAssertionFunction(checkInteger, c.fun = "c_check_integer") #' @export #' @rdname checkInteger assert_integer = assertInteger #' @export #' @include makeTest.R #' @rdname checkInteger testInteger = makeTestFunction(checkInteger, c.fun = "c_check_integer") #' @export #' @rdname checkInteger test_integer = testInteger #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkInteger expect_integer = makeExpectationFunction(checkInteger, c.fun = "c_check_integer") checkmate/R/checkNumeric.R0000644000176200001440000000264512762010266015133 0ustar liggesusers#' Check that an argument is a vector of type numeric #' #' @templateVar fn Numeric #' @template x #' @template na-handling #' @inheritParams checkVector #' @template bounds #' @param finite [\code{logical(1)}]\cr #' Check for only finite values? Default is \code{FALSE}. #' @template null.ok #' @template checker #' @family basetypes #' @useDynLib checkmate c_check_numeric #' @export #' @examples #' testNumeric(1) #' testNumeric(1, min.len = 1, lower = 0) checkNumeric = function(x, lower = -Inf, upper = Inf, finite = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) { .Call(c_check_numeric, x, lower, upper, finite, any.missing, all.missing, len, min.len, max.len, unique, names, null.ok) } #' @export #' @rdname checkNumeric check_numeric = checkNumeric #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkNumeric assertNumeric = makeAssertionFunction(checkNumeric, c.fun = "c_check_numeric") #' @export #' @rdname checkNumeric assert_numeric = assertNumeric #' @export #' @include makeTest.R #' @rdname checkNumeric testNumeric = makeTestFunction(checkNumeric, c.fun = "c_check_numeric") #' @export #' @rdname checkNumeric test_numeric = testNumeric #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkNumeric expect_numeric = makeExpectationFunction(checkNumeric, c.fun = "c_check_numeric") checkmate/R/checkFactor.R0000644000176200001440000000677012762010266014752 0ustar liggesusers#' Check if an argument is a factor #' #' @templateVar fn Factor #' @template x #' @inheritParams checkVector #' @param levels [\code{character}]\cr #' Vector of allowed factor levels. #' @param ordered [\code{logical(1)}]\cr #' Check for an ordered factor? If \code{FALSE} or \code{TRUE}, checks explicitly #' for an unordered or ordered factor, respectively. #' Default is \code{NA} which does not perform any additional check. #' @param empty.levels.ok [\code{logical(1)}]\cr #' Are empty levels allowed? #' Default is \code{TRUE}. #' @param n.levels [\code{integer(1)}]\cr #' Exact number of factor levels. #' Default is \code{NULL} (no check). #' @param min.levels [\code{integer(1)}]\cr #' Minimum number of factor levels. #' Default is \code{NULL} (no check). #' @param max.levels [\code{integer(1)}]\cr #' Maximum number of factor levels. #' Default is \code{NULL} (no check). #' @template null.ok #' @template checker #' @family basetypes #' @useDynLib checkmate c_check_factor #' @export #' @examples #' x = factor("a", levels = c("a", "b")) #' testFactor(x) #' testFactor(x, empty.levels.ok = FALSE) checkFactor = function(x, levels = NULL, ordered = NA, empty.levels.ok = TRUE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, n.levels = NULL, min.levels = NULL, max.levels = NULL, unique = FALSE, names = NULL, null.ok = FALSE) { .Call(c_check_factor, x, any.missing, all.missing, len, min.len, max.len, unique, names, null.ok) %and% checkFactorLevels(x, levels, ordered, empty.levels.ok, n.levels, min.levels, max.levels) } checkFactorLevels = function(x , levels = NULL, ordered = NA, empty.levels.ok = TRUE, n.levels = NULL, min.levels = NULL, max.levels = NULL) { if (!is.null(x)) { if (!is.null(levels)) { qassert(levels, "S") if (!setequal(levels(x), levels)) return(sprintf("Must have levels: %s", paste0(levels, collapse = ","))) } qassert(ordered, "b1") if (!is.na(ordered)) { x.ordered = is.ordered(x) if (ordered && !x.ordered) return("Must be an ordered factor, but is unordered") else if (!ordered && x.ordered) return("Must be an unordered factor, but is ordered") } qassert(empty.levels.ok, "B1") if (!empty.levels.ok) { empty = setdiff(levels(x), levels(droplevels(x))) if (length(empty) > 0L) return(sprintf("Has has empty levels '%s'", paste0(empty, collapse = "','"))) } if (!is.null(n.levels)) { qassert(n.levels, "X1") if (length(levels(x)) != n.levels) return(sprintf("Must have exactly %i levels", n.levels)) } if (!is.null(min.levels)) { qassert(min.levels, "X1") if (length(levels(x)) < min.levels) return(sprintf("Must have at least %i levels", min.levels)) } if (!is.null(max.levels)) { qassert(max.levels, "X1") if (length(levels(x)) > max.levels) return(sprintf("Must have at most %i levels", max.levels)) } } return(TRUE) } #' @export #' @rdname checkFactor check_factor = checkFactor #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkFactor assertFactor = makeAssertionFunction(checkFactor) #' @export #' @rdname checkFactor assert_factor = assertFactor #' @export #' @include makeTest.R #' @rdname checkFactor testFactor = makeTestFunction(checkFactor) #' @export #' @rdname checkFactor test_factor = testFactor #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkFactor expect_factor = makeExpectationFunction(checkFactor) checkmate/R/checkEnvironment.R0000644000176200001440000000313712762010266016032 0ustar liggesusers#' Check if an argument is an environment #' #' @templateVar fn Environment #' @template x #' @param contains [\code{character}]\cr #' Vector of object names expected in the environment. #' Defaults to \code{character(0)}. #' @template null.ok #' @template checker #' @family basetypes #' @export #' @examples #' ee = as.environment(list(a = 1)) #' testEnvironment(ee) #' testEnvironment(ee, contains = "a") checkEnvironment = function(x, contains = character(0L), null.ok = FALSE) { qassert(contains, "S") if (is.null(x)) { if (identical(null.ok, TRUE)) return(TRUE) return("Must be an environment, not 'NULL'") } if (!is.environment(x)) return(sprintf("Must be an environment%s, not '%s'", if (isTRUE(null.ok)) " (or 'NULL')" else "", guessType(x))) if (length(contains) > 0L) { w = wf(contains %nin% ls(x, all.names = TRUE)) if (length(w) > 0L) return(sprintf("Must contain an object with name '%s'", contains[w])) } return(TRUE) } #' @export #' @rdname checkEnvironment check_environment = checkEnvironment #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkEnvironment assertEnvironment = makeAssertionFunction(checkEnvironment) #' @export #' @rdname checkEnvironment assert_environment = assertEnvironment #' @export #' @include makeTest.R #' @rdname checkEnvironment testEnvironment = makeTestFunction(checkEnvironment) #' @export #' @rdname checkEnvironment test_environment = testEnvironment #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkEnvironment expect_environment = makeExpectationFunction(checkEnvironment) checkmate/R/anyNaN.R0000644000176200001440000000072112762010266013710 0ustar liggesusers#' Check if an object contains NaN values #' #' @description #' Supported are atomic types (see \code{\link[base]{is.atomic}}), lists and data frames. #' #' @param x [\code{ANY}]\cr #' Object to check. #' @return [\code{logical(1)}] Returns \code{TRUE} if any element is \code{NaN}. #' @useDynLib checkmate c_any_nan #' @export #' @examples #' anyNaN(1:10) #' anyNaN(c(1:10, NaN)) #' iris[3, 3] = NaN #' anyNaN(iris) anyNaN = function(x) { .Call(c_any_nan, x) } checkmate/R/checkScalarNA.R0000644000176200001440000000224012762010266015144 0ustar liggesusers#' Check if an argument is a single missing value #' #' @templateVar fn ScalarNA #' @template x #' @template null.ok #' @template checker #' @family scalars #' @export #' @examples #' testScalarNA(1) #' testScalarNA(NA_real_) #' testScalarNA(rep(NA, 2)) checkScalarNA = function(x, null.ok = FALSE) { if (is.null(x)) { if (identical(null.ok, TRUE)) return(TRUE) return("Must be a scalar missing value, not 'NULL'") } if (length(x) != 1L || !is.na(x)) return(paste0("Must be a scalar missing value", if (isTRUE(null.ok)) " (or 'NULL')" else "")) return(TRUE) } #' @export #' @rdname checkScalarNA check_scalar_na = checkScalarNA #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkScalarNA assertScalarNA = makeAssertionFunction(checkScalarNA) #' @export #' @rdname checkScalarNA assert_scalar_na = assertScalarNA #' @export #' @include makeTest.R #' @rdname checkScalarNA testScalarNA = makeTestFunction(checkScalarNA) #' @export #' @rdname checkScalarNA test_scalar_na = testScalarNA #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkScalarNA expect_scalar_na = makeExpectationFunction(checkScalarNA) checkmate/R/checkArray.R0000644000176200001440000000305612762010266014604 0ustar liggesusers#' Check if an argument is an array #' #' @templateVar fn Array #' @template x #' @template mode #' @param any.missing [\code{logical(1)}]\cr #' Are missing values allowed? Default is \code{TRUE}. #' @param d [\code{integer(1)}]\cr #' Exact number of dimensions of array \code{x}. #' Default is \code{NULL} (no check). #' @param min.d [\code{integer(1)}]\cr #' Minimum number of dimensions of array \code{x}. #' Default is \code{NULL} (no check). #' @param max.d [\code{integer(1)}]\cr #' Maximum number of dimensions of array \code{x}. #' Default is \code{NULL} (no check). #' @template null.ok #' @template checker #' @family basetypes #' @family compound #' @useDynLib checkmate c_check_array #' @export #' @examples #' checkArray(array(1:27, dim = c(3, 3, 3)), d = 3) checkArray = function(x, mode = NULL, any.missing = TRUE, d = NULL, min.d = NULL, max.d = NULL, null.ok = FALSE) { .Call(c_check_array, x, mode, any.missing, d, min.d, max.d, null.ok) } #' @export #' @rdname checkArray check_array = checkArray #' @export #' @include makeAssertion.R #' @template assert #' @rdname checkArray assertArray = makeAssertionFunction(checkArray, c.fun = "c_check_array") #' @export #' @rdname checkArray assert_array = assertArray #' @export #' @include makeTest.R #' @rdname checkArray testArray = makeTestFunction(checkArray, c.fun = "c_check_array") #' @export #' @rdname checkArray test_array = testArray #' @export #' @include makeExpectation.R #' @template expect #' @rdname checkArray expect_array = makeExpectationFunction(checkArray, c.fun = "c_check_array") checkmate/R/zzz.R0000644000176200001440000000663713006323272013371 0ustar liggesusers#' @description #' #' \describe{ #' \item{Homepage:}{\url{https://github.com/mllg/checkmate}} #' \item{Bug Reports:}{\url{https://github.com/mllg/checkmate/issues}} #' } #' #' @section Overview of implemented functions: #' #' Check scalars: #' \itemize{ #' \item{\code{\link{checkFlag}}} #' \item{\code{\link{checkCount}}} #' \item{\code{\link{checkNumber}}} #' \item{\code{\link{checkInt}}} #' \item{\code{\link{checkString}}} #' \item{\code{\link{checkScalar}}} #' \item{\code{\link{checkScalarNA}}} #' } #' #' Check vectors: #' \itemize{ #' \item{\code{\link{checkLogical}}} #' \item{\code{\link{checkNumeric}}} #' \item{\code{\link{checkInteger}}} #' \item{\code{\link{checkIntegerish}}} #' \item{\code{\link{checkComplex}}} #' \item{\code{\link{checkFactor}}} #' \item{\code{\link{checkList}}} #' \item{\code{\link{checkVector}}} #' \item{\code{\link{checkAtomic}}} #' \item{\code{\link{checkAtomicVector}}} #' } #' #' Check attributes: #' \itemize{ #' \item{\code{\link{checkClass}}} #' \item{\code{\link{checkNames}}} #' \item{\code{\link{checkNamed}}} #' } #' #' Check compound types: #' \itemize{ #' \item{\code{\link{checkMatrix}}} #' \item{\code{\link{checkArray}}} #' \item{\code{\link{checkDataFrame}}} #' \item{\code{\link{checkDataTable}}} #' \item{\code{\link{checkTibble}}} #' } #' #' Check other built-in R types: #' \itemize{ #' \item{\code{\link{checkNull}}} #' \item{\code{\link{checkEnvironment}}} #' \item{\code{\link{checkFunction}}} #' \item{\code{\link{checkDate}}} #' } #' #' Check sets: #' \itemize{ #' \item{\code{\link{checkChoice}}} #' \item{\code{\link{checkSubset}}} #' \item{\code{\link{checkSetEqual}}} #' } #' #' File IO: #' \itemize{ #' \item{\code{\link{checkFileExists}}} #' \item{\code{\link{checkDirectoryExists}}} #' \item{\code{\link{checkPathForOutput}}} #' \item{\code{\link{checkAccess}}} #' } #' #' Safe coercion to integer: #' \itemize{ #' \item{\code{\link{asCount}}} #' \item{\code{\link{asInt}}} #' \item{\code{\link{asInteger}}} #' } #' #' Quick argument checks using a DSL: #' \itemize{ #' \item{\code{\link{qassert}}} #' \item{\code{\link{qassertr}}} #' } #' #' Misc: #' \itemize{ #' \item{\code{\link{checkOS}} (check operating system)} #' \item{\code{\link{assert}} (combine multiple checks into an assertion)} #' \item{\code{\link{anyMissing}}} #' \item{\code{\link{allMissing}}} #' \item{\code{\link{anyNaN}}} #' \item{\code{\link{wf}} (which.first and which.last)} #' } #' #' @import backports #' @importFrom utils head tail packageVersion getFromNamespace "_PACKAGE" checkmate = new.env(parent = emptyenv()) checkmate$os = c("windows", "mac", "linux", "solaris")[match(tolower(Sys.info()["sysname"]), c("windows", "darwin", "linux", "sunos"))] checkmate$listtypefuns = list2env(list( "logical" = is.logical, "integer" = is.integer, "integerish" = isIntegerish, "double" = is.double, "numeric" = is.numeric, "complex" = is.complex, "character" = is.character, "factor" = is.factor, "atomic" = is.atomic, "vector" = is.vector, "atomicvector" = function(x) !is.null(x) && is.atomic(x), "array" = is.array, "matrix" = is.matrix, "function" = is.function, "environment" = is.environment, "list" = is.list, "null" = is.null )) .onUnload <- function (libpath) { library.dynam.unload("checkmate", libpath) # nocov } checkmate/R/anyMissing.R0000644000176200001440000000212712762010266014647 0ustar liggesusers#' Check if an object contains missing values #' #' @description #' Supported are atomic types (see \code{\link[base]{is.atomic}}), lists and data frames. #' Missingness is defined as \code{NA} or \code{NaN} for atomic types and data frame columns, #' \code{NULL} is defined as missing for lists.\cr #' \code{allMissing} applied to a \code{data.frame} returns \code{TRUE} if at least one column has #' only non-missing values. If you want to perform the less frequent check that there is not a single #' non-missing observation present in the \code{data.frame}, use \code{all(sapply(df, allMissing))} #' instead. #' #' @param x [\code{ANY}]\cr #' Object to check. #' @return [\code{logical(1)}] Returns \code{TRUE} if any (\code{anyMissing}) or all (\code{allMissing}) #' elements of \code{x} are missing (see details), \code{FALSE} otherwise. #' @useDynLib checkmate c_any_missing #' @export #' @examples #' anyMissing(c(1, 1)) #' anyMissing(c(1, NA)) #' anyMissing(list(1, NULL)) #' #' x = iris #' x[, "Species"] = NA #' anyMissing(x) #' allMissing(x) anyMissing = function(x) { .Call(c_any_missing, x) } checkmate/R/AssertCollection.R0000644000176200001440000000375312762010266016011 0ustar liggesusers#' Collect multiple assertions #' @name AssertCollection #' #' @param collection [\code{AssertCollection}]\cr #' Object of type \dQuote{AssertCollection} (constructed via \code{makeAssertCollection}). #' @description #' The function \code{makeAssertCollection()} returns a simple stack-like #' closure you can pass to all functions of the \code{assert*}-family. #' All messages get collected and can be reported with \code{reportAssertions()}. #' Alternatively, you can easily write your own report function or customize the the output of #' the report function to a certain degree. #' See the example on how to push custom messages or retrieve all stored messages. #' @return \code{makeAssertCollection()} returns an object of class \dQuote{AssertCollection} and #' \code{reportCollection} returns invisibly \code{TRUE} if no error is thrown (i.e., no message was #' collected). #' @examples #' x = "a" #' coll = makeAssertCollection() #' #' print(coll$isEmpty()) #' assertNumeric(x, add = coll) #' coll$isEmpty() #' coll$push("Custom error message") #' coll$getMessages() #' \dontrun{ #' reportAssertions(coll) #' } NULL #' @export #' @rdname AssertCollection makeAssertCollection = function() { msgs = character(0L) x = list(push = function(msg) msgs <<- c(msgs, msg), getMessages = function() msgs, isEmpty = function() length(msgs) == 0L) class(x) = "AssertCollection" x } #' @export print.AssertCollection = function(x, ...) { n = length(x$getMessages()) if (n == 0L) { cat("Empty collection\n") } else { cat(sprintf("Collection of %i assertion%s.\n", n, ifelse(n > 1L, "s", ""))) } } #' @export #' @rdname AssertCollection reportAssertions = function(collection) { assertClass(collection, "AssertCollection") if (!collection$isEmpty()) { msgs = collection$getMessages() context = "%i assertions failed:" err = c(sprintf(context, length(msgs)), strwrap(msgs, prefix = " * ")) stop(simpleError(paste0(err, collapse = "\n"), call = sys.call(1L))) } invisible(TRUE) } checkmate/R/anyInfinite.R0000644000176200001440000000100312762010266014773 0ustar liggesusers#' Check if an object contains infinite values #' #' @description #' Supported are atomic types (see \code{\link[base]{is.atomic}}), lists and data frames. #' #' @param x [\code{ANY}]\cr #' Object to check. #' @return [\code{logical(1)}] Returns \code{TRUE} if any element is \code{-Inf} or \code{Inf}. #' @useDynLib checkmate c_any_infinite #' @export #' @examples #' anyInfinite(1:10) #' anyInfinite(c(1:10, Inf)) #' iris[3, 3] = Inf #' anyInfinite(iris) anyInfinite = function(x) { .Call(c_any_infinite, x) } checkmate/vignettes/0000755000176200001440000000000013006331417014204 5ustar liggesuserscheckmate/vignettes/checkmate.Rmd0000644000176200001440000002757413006323271016612 0ustar liggesusers--- title: "Checkmate" author: "Michel Lang" date: "`r Sys.Date()`" output: rmarkdown::html_vignette vignette: > %\VignetteIndexEntry{checkmate} %\VignetteEngine{knitr::rmarkdown} %\VignetteEncoding{UTF-8} --- ```{r,include=FALSE} library(checkmate) ``` Ever used an R function that produced a not-very-helpful error message, just to discover after minutes of debugging that you simply passed a wrong argument? Blaming the laziness of the package author for not doing such standard checks (in a dynamically typed language such as R) is at least partially unfair, as R makes theses types of checks cumbersome and annoying. Well, that's how it was in the past. Enter checkmate. Virtually **every standard type of user error** when passing arguments into function can be caught with a simple, readable line which produces an **informative error message** in case. A substantial part of the package was written in C to **minimize any worries about execution time overhead**. ## Intro As a motivational example, consider you have a function to calculate the faculty of a natural number and the user may choose between using either the stirling approximation or R's `factorial` function (which internally uses the gamma function). Thus, you have two arguments, `n` and `method`. Argument `n` must obviously be a positive natural number and `method` must be either `"stirling"` or `"factorial"`. Here is a version of all the hoops you need to jump through to ensure that these simple requirements are met: ```{r} fact <- function(n, method = "stirling") { if (length(n) != 1) stop("Argument 'n' must have length 1") if (!is.numeric(n)) stop("Argument 'n' must be numeric") if (is.na(n)) stop("Argument 'n' may not be NA") if (is.double(n)) { if (is.nan(n)) stop("Argument 'n' may not be NaN") if (is.infinite(n)) stop("Argument 'n' must be finite") if (abs(n - round(n, 0)) > sqrt(.Machine$double.eps)) stop("Argument 'n' must be an integerish value") n <- as.integer(n) } if (n < 0) stop("Argument 'n' must be >= 0") if (length(method) != 1) stop("Argument 'method' must have length 1") if (!is.character(method) || !method %in% c("stirling", "factorial")) stop("Argument 'method' must be either 'stirling' or 'factorial'") if (method == "factorial") factorial(n) else sqrt(2 * pi * n) * (n / exp(1))^n } ``` And for comparison, here is the same function using checkmate: ```{r} fact <- function(n, method = "stirling") { assertCount(n) assertChoice(method, c("stirling", "factorial")) if (method == "factorial") factorial(n) else sqrt(2 * pi * n) * (n / exp(1))^n } ``` ## Function overview The functions can be split into four functional groups, indicated by their prefix. If prefixed with `assert`, an error is thrown if the corresponding check fails. Otherwise, the checked object is returned invisibly. There are many different coding styles out there in the wild, but most R programmers stick to either `camelBack` or `underscore_case`. Therefore, `checkmate` offers all functions in both flavors: `assert_count` is just an alias for `assertCount` but allows you to retain your favorite style. The family of functions prefixed with `test` always return the check result as logical value. Again, you can use `test_count` and `testCount` interchangeably. Functions starting with `check` return the error message as a string (or `TRUE` otherwise) and can be used if you need more control and, e.g., want to grep on the returned error message. `expect` is the last family of functions and is intended to be used with the [testthat package](https://cran.r-project.org/package=testthat). All performed checks are logged into the `testthat` reporter. Because `testthat` uses the `underscore_case`, the extension functions only come in the underscore style. All functions are categorized into objects to check on the [package help page](https://mllg.github.io/checkmate/reference/checkmate-package). ## In case you miss flexibility You can use [assert](https://mllg.github.io/checkmate/reference/assert) to perform multiple checks at once and throw an assertion if all checks fail. Here is an example where we check that x is either of class `foo` or class `bar`: ```{r} f <- function(x) { assert( checkClass(x, "foo"), checkClass(x, "bar") ) } ``` Note that `assert(, combine = "or")` and `assert(, combine = "and")` allow to control the logical combination of the specified checks, and that the former is the default. ## Argument Checks for the Lazy The following functions allow a special syntax to define argument checks using a special format specification. E.g., `qassert(x, "I+")` asserts that `x` is an integer vector with at least one element and no missing values. This very simple domain specific language covers a large variety of frequent argument checks with only a few keystrokes. You choose what you like best. * [qassert](https://mllg.github.io/checkmate/reference/qassert) * [qassertr](https://mllg.github.io/checkmate/reference/qassert) ## checkmate as testthat extension To extend [testthat](https://cran.r-project.org/package=testthat), you need to IMPORT, DEPEND or SUGGEST on the `checkmate` package. Here is a minimal example: ```{r,eval=FALSE} # file: tests/test-all.R library(testthat) library(checkmate) # for testthat extensions test_check("mypkg") ``` Now you are all set and can use more than 30 new expectations in your tests. ```{r,eval=FALSE} test_that("checkmate is a sweet extension for testthat", { x = runif(100) expect_numeric(x, len = 100, any.missing = FALSE, lower = 0, upper = 1) # or, equivalent, using the lazy style: qexpect(x, "N100[0,1]") }) ``` ## Speed considerations In comparison with tediously writing the checks yourself in R (c.f. factorial example at the beginning of the vignette), R is sometimes a tad faster while performing checks on scalars. This seems odd at first, because checkmate is mostly written in C and should be comparably fast. Yet many of the functions in the `base` package are not regular functions, but primitives. While primitives jump directly into the C code, checkmate has to use the considerably slower `.Call` interface. As a result, it is possible to write (very simple) checks using only the base functions which, under some circumstances, slightly outperform checkmate. However, if you go one step further and wrap the custom check into a function to convenient re-use it, the performance gain is often lost (see benchmark 1). For larger objects the tide has turned because checkmate avoids many unnecessary intermediate variables. Also note that the quick/lazy implementation in `qassert`/`qtest`/`qexpect` is often a tad faster because only two arguments have to be evaluated (the object and the rule) to determine the set of checks to perform. Below you find some (probably unrepresentative) benchmark. But also note that this one here has been executed from inside `knitr` which is often the cause for outliers in the measured execution time. Better run the benchmark yourself to get unbiased results. ### Benchmark 1: Assert that `x` is a flag ```{r,dev="svg",fig.width=6,fig.height=4} library(ggplot2) library(microbenchmark) x = TRUE r = function(x, na.ok = FALSE) { stopifnot(is.logical(x), length(x) == 1, na.ok || !is.na(x)) } cm = function(x) assertFlag(x) cmq = function(x) qassert(x, "B1") mb = microbenchmark(r(x), cm(x), cmq(x)) print(mb) autoplot(mb) ``` ### Benchmark 2: Assert that `x` is a numeric of length 1000 with no missing nor NaN values ```{r,dev="svg",fig.width=6,fig.height=4} x = runif(1000) r = function(x) stopifnot(is.numeric(x) && length(x) == 1000 && all(!is.na(x) & x >= 0 & x <= 1)) cm = function(x) assertNumeric(x, len = 1000, any.missing = FALSE, lower = 0, upper = 1) cmq = function(x) qassert(x, "N1000[0,1]") mb = microbenchmark(r(x), cm(x), cmq(x)) print(mb) autoplot(mb) ``` ### Benchmark 3: Assert that `x` is a character vector with no missing values nor empty strings ```{r,dev="svg",fig.width=6,fig.height=4} x = sample(letters, 10000, replace = TRUE) r = function(x) stopifnot(is.character(x) && !any(is.na(x)) && all(nchar(x) > 0)) cm = function(x) assertCharacter(x, any.missing = FALSE, min.chars = 1) cmq = function(x) qassert(x, "S+[1,]") mb = microbenchmark(r(x), cm(x), cmq(x)) print(mb) autoplot(mb) ``` ### Benchmark 4: Assert that `x` is a data frame with no missing values ```{r,dev="svg",fig.width=6,fig.height=4} N = 10000 x = data.frame(a = runif(N), b = sample(letters[1:5], N, replace = TRUE), c = sample(c(FALSE, TRUE), N, replace = TRUE)) r = function(x) is.data.frame(x) && !any(sapply(x, function(x) any(is.na(x)))) cm = function(x) testDataFrame(x, any.missing = FALSE) cmq = function(x) qtest(x, "D") mb = microbenchmark(r(x), cm(x), cmq(x)) print(mb) autoplot(mb) # checkmate tries to stop as early as possible x$a[1] = NA mb = microbenchmark(r(x), cm(x), cmq(x)) print(mb) autoplot(mb) ``` ## Extending checkmate To extend checkmate a custom `check*` function has to be written. For example, to check for a square matrix one can re-use parts of checkmate and extend the check with additional functionality: ```{r} checkSquareMatrix = function(x, mode = NULL) { # check functions must return TRUE on success # and a custom error message otherwise res = checkMatrix(x, mode = mode) if (!isTRUE(res)) return(res) if (nrow(x) != ncol(x)) return("Must be square") return(TRUE) } # a quick test: X = matrix(1:9, nrow = 3) checkSquareMatrix(X) checkSquareMatrix(X, mode = "character") checkSquareMatrix(X[1:2, ]) ``` The respective counterparts to the `check`-function can be created using the constructors [makeAssertionFunction](https://mllg.github.io/checkmate/reference/makeAssertion), [makeTestFunction](https://mllg.github.io/checkmate/reference/makeTest) and [makeExpectationFunction](https://mllg.github.io/checkmate/reference/makeExpectation): ```{r} # For assertions: assert_square_matrix = assertSquareMatrix = makeAssertionFunction(checkSquareMatrix) print(assertSquareMatrix) # For tests: test_square_matrix = testSquareMatrix = makeTestFunction(checkSquareMatrix) print(testSquareMatrix) # For expectations: expect_square_matrix = makeExpectationFunction(checkSquareMatrix) print(expect_square_matrix) ``` Note that all the additional arguments `.var.name`, `add`, `info` and `label` are automatically joined with the function arguments of your custom check function. Also note that if you define these functions inside an R package, the constructors are called at build-time (thus, there is no negative impact on the runtime). ## Calling checkmate from C/C++ The package registers two functions which can be used in other packages' C/C++ code for argument checks. ```{c,eval=FALSE} SEXP qassert(SEXP x, const char *rule, const char *name); Rboolean qtest(SEXP x, const char *rule); ``` These are the counterparts to [qassert](https://mllg.github.io/checkmate/reference/qassert) and [qtest](https://mllg.github.io/checkmate/reference/qassert). Due to their simplistic interface, they perfectly suit the requirements of most type checks in C/C++. For detailed background information on the register mechanism, see the [Exporting C Code](http://r-pkgs.had.co.nz/src.html#clang) section in Hadley's Book "R Packages" or [WRE](https://cran.r-project.org/doc/manuals/r-release/R-exts.html#Registering-native-routines). Here is a step-by-step guide to get you started: 1. Add `checkmate` to your "Imports" and LinkingTo" sections in your DESCRIPTION file. 2. Create a stub file C source file which pulls in the provided C functions in order to compile them for your package. See example below. 3. Include the provided header file `` in each compilation unit where you want to use checkmate. ```{c,eval=FALSE} /* Example for (2), "checkmate_stub.c":*/ #include #include ``` ## Session Info For the sake of completeness, here the `sessionInfo()` for the benchmark (but remember the note before on `knitr` possibly biasing the results). ```{r} sessionInfo() ``` checkmate/README.md0000644000176200001440000000372613006323271013462 0ustar liggesusers# checkmate [![CRAN_Status_Badge](http://www.r-pkg.org/badges/version/checkmate)](https://cran.r-project.org/package=checkmate) [![Build Status](https://travis-ci.org/mllg/checkmate.svg?branch=master)](https://travis-ci.org/mllg/checkmate) [![Build status](https://ci.appveyor.com/api/projects/status/y4ayps61hjd3375o/branch/master?svg=true)](https://ci.appveyor.com/project/mllg/checkmate/branch/master) [![Coverage Status](https://img.shields.io/coveralls/mllg/checkmate.svg)](https://coveralls.io/r/mllg/checkmate?branch=master) Fast and versatile argument checks for R. Ever used an R function that produced a not-very-helpful error message, just to discover after minutes of debugging that you simply passed a wrong argument? Blaming the laziness of the package author for not doing such standard checks (in a dynamically typed language such as R) is at least partially unfair, as R makes theses types of checks cumbersome and annoying. Well, that's how it was in the past. Enter checkmate. Virtually **every standard type of user error** when passing arguments into function can be caught with a simple, readable line which produces an **informative error message** in case. A substantial part of the package was written in C to **minimize any worries about execution time overhead**. Furthermore, the package provides over 30 expectations to extend the popular [testthat package](https://cran.r-project.org/package=testthat) for unit tests. ## Installation For the stable release, just install the latest version from [CRAN](https://cran.r-project.org/package=checkmate): ```{R} install.packages("checkmate") ``` For the development version, use [devtools](https://cran.r-project.org/package=devtools): ```{R} devtools::install_github("mllg/checkmate") ``` ## Resources * [NEWS](https://github.com/mllg/checkmate/blob/master/NEWS.md) * [Documentation/Vignettes](https://mllg.github.io/checkmate/) * [Grouped function reference](https://mllg.github.io/checkmate/reference/checkmate-package) checkmate/MD50000644000176200001440000002545413006417455012525 0ustar liggesusers0193c109400e6c52ba3fbec2c5e6482a *DESCRIPTION b0b6dd0a52cf41d9eb9eef17c4014538 *LICENSE c3c1ba41ff9f85381b7fd46b66b1a1b1 *NAMESPACE 6d91eb2907ee1bf234fb540e68ff304b *NEWS.md f0fc2aeb92b3d2014f6357308fd80954 *R/AssertCollection.R a7fc65b769f9477797c56c8c2af12339 *R/allMissing.R d4b005e269d2845ff89bed357a4e3d5f *R/anyInfinite.R 4e5ba9b259b46bf424e3ce1000f68e90 *R/anyMissing.R 65edb5b66b8a66217713a6aa2df5f3b9 *R/anyNaN.R dfee030e0ab9b5152e1b4e09c1823ff9 *R/asInteger.R 5ddf157b76c71ab46ca7848dc0dd8a9f *R/assert.R 38dddb2ec8e44940351a239af16701b8 *R/checkAccess.R 7b56d45a334baf5ed3df5351e21f7beb *R/checkArray.R a7bc9e4293f16479733b9c62a06fae89 *R/checkAtomic.R 54b07d2e24590aa90dba84b7c4ab4b55 *R/checkAtomicVector.R f8d12e0a4e649ff526589c3ed0789941 *R/checkCharacter.R ac55cf18b08a273e784282efcdd1434a *R/checkChoice.R adeb8894c3536a12dc037b30014f1041 *R/checkClass.R 7e2a0da23501614b4a5234c7716c387a *R/checkComplex.R e70bad27622e217fa60952d45b2ce1e3 *R/checkCount.R ee5ad9523512931c12c6fafa0af82511 *R/checkDataFrame.R b4f872829e2192130345d8f524e3210d *R/checkDataTable.R 2a4fc16432143d06eae0e85dd1256666 *R/checkDate.R d32c00660ef9c4b43866f454670736fe *R/checkDirectoryExists.R 9774a3bc179500c6433cd36a2c2caa35 *R/checkEnvironment.R 1030793675597a52ecaffe09b113085f *R/checkFactor.R 96f53778f75a3e3309a3780479114a33 *R/checkFileExists.R 9e3dac4031f2b1a2538a3c6f8be8d1f7 *R/checkFlag.R 6713455828332e3e08bcf3f20b9ddf55 *R/checkFunction.R ff4e60653844fc698b0ab6e219839219 *R/checkInt.R 65e40b037e973393d9c8aee5ae9728e8 *R/checkInteger.R 7b0608524f1f136715dc8e7fc03a5e7d *R/checkIntegerish.R a7a992b2dd3fefc453b129585044047b *R/checkList.R 44429c270ff2a07a54ccda66a89e712a *R/checkLogical.R a77907ff924cf709c17dc5f9fec7a64b *R/checkMatrix.R be0a58caf1587d565bd2e4a220bec9f9 *R/checkNamed.R 771b8e32022efeea127bbe6ade14f116 *R/checkNames.R 0b8ae1aa94964c09014463b1b684d381 *R/checkNull.R 304c2c610fe9f23a383e478b202158c6 *R/checkNumber.R 22f90d22934205b58607457387dabe02 *R/checkNumeric.R 489644560780caf623590aa036f74ef9 *R/checkOS.R 3a28b57223df126616e2a9ef247163b5 *R/checkPathForOutput.R 6153863470172efebe1f720d99a55069 *R/checkScalar.R e595ea93726a9bb38111f19f76349374 *R/checkScalarNA.R 1c3bff5a57df9af3496ca00b9378c0d4 *R/checkSetEqual.R 94bf1562cf0d489287575536c1880f39 *R/checkString.R 4e38f1166137bbb356650117908d42c9 *R/checkSubset.R 880ba9eb1b3515066f4f93a6ebdb81bf *R/checkTibble.R 444955685dac38375d5843f1b603b83b *R/checkVector.R 80ae11a07596493bea7960e2eb65dd73 *R/coalesce.R 70aa7f27fcf8bbc86e2308f07e74f91f *R/helper.R bd5ff342b970d92b9fa99f437af82b72 *R/isIntegerish.R ff84258ed1df90286590f258ac0fb831 *R/makeAssertion.R b64dfbf277899287a6ed1a67ba0655d0 *R/makeExpectation.R 81ed256883d6f8b55f9d1278c230997f *R/makeTest.R bb9920804c833240611d116614878467 *R/matchArg.R ff4363de4c36a2bc34aa0a9aa5be7db2 *R/qassert.R 6e854ef50da86998ead1aff70307ebdf *R/qassertr.R 3f12a573026bdfe1a99ccd4678f2f4b1 *R/vname.R e461317d090f6344d1e56dc1cbfd4c20 *R/wfwl.R 9868d692fc49021dce20ddbc673aaa70 *R/zzz.R 0893877bc2d2b4f97690b53461f25b52 *README.md 4248993c2fe38bf5d861ef0a52988595 *build/vignette.rds 7553992bbffab1702dbb096f24d05b3d *inst/doc/checkmate.R e05bcd2c1512c7632a9607f9632dd5ff *inst/doc/checkmate.Rmd 6a98953bdfcacad4f6c67454abc24f9e *inst/doc/checkmate.html 022139fefe30297f3f1ef95ae27f3901 *inst/include/checkmate.h d6a785640832fcd3d6ca78ed101cfdb7 *inst/include/checkmate_stub.c 28bd8a79ba13344f3e35f6e765fa5610 *man/AssertCollection.Rd 14427c399c124c522039ca392985a90c *man/anyInfinite.Rd 2bd1e1737a875d4b6211235645c2c11b *man/anyMissing.Rd 97b1d46159b7a40fef373d56d4e213aa *man/anyNaN.Rd f31c487005ee85ced1c30e5605fb1729 *man/asInteger.Rd 8c5d6d3c64ba54a23c861cb19f11479c *man/assert.Rd 97d54daa72a28f5bae94069809b42375 *man/checkAccess.Rd 1f452772d7fed32c66564e206b846b8b *man/checkArray.Rd b50bd25a2b7750040ddc1052ead57425 *man/checkAtomic.Rd 4ae48a3afb490e36303710df87bb075b *man/checkAtomicVector.Rd 892eb8a29ba6346e180f4b252484a045 *man/checkCharacter.Rd bee5880f5573d5804c73432d32c4b9e6 *man/checkChoice.Rd 4ea1200f82305bf20345c111298590d8 *man/checkClass.Rd c32eaac939edbfc419285703e92e4f90 *man/checkComplex.Rd 86846062e2aa1831307147fcdf39b279 *man/checkCount.Rd 6e56b2b7f800fdaf1224c12dba58b843 *man/checkDataFrame.Rd f265d9d6c00e977fbe6babf3ce0b86d5 *man/checkDataTable.Rd 5b86e7f263cf420dc32648b0a950cf4e *man/checkDate.Rd 59e2cd22b02d5caf72190bb4e1acf6bd *man/checkDirectoryExists.Rd 7a997b32380f5c3758c37a5b277e03b3 *man/checkEnvironment.Rd 5ba4ced722edf2c4b086022fbae07f8a *man/checkFactor.Rd 046d14a0340e003cb33fba85ce0a8885 *man/checkFileExists.Rd bf611ac4c01e06bfb64ee94d9f6e7ee8 *man/checkFlag.Rd 68a9a178bb73ccec387c9782069bebd0 *man/checkFunction.Rd 57be1623f3104297eb2c3d07c1ed5417 *man/checkInt.Rd a8c4994092627fae92ab76d0631c47ce *man/checkInteger.Rd d3fc142f3ff330c55618facf396cb5fa *man/checkIntegerish.Rd 4265abc1e0bd7e346ccb77af94ba35f1 *man/checkList.Rd 587c14b481b84e37d44ef4114d299f83 *man/checkLogical.Rd 7439058a85062a5ee701edd771186fd5 *man/checkMatrix.Rd 3b18bee8b0b7dc17d3c1b5065be606e7 *man/checkNamed.Rd 2c0a82ef3ab27810b52dc7f45b2c6b4e *man/checkNames.Rd 3bf879a369c312fc16a8467f443b2dfb *man/checkNull.Rd 9aad98b6e9f8e5f883c8509e83709837 *man/checkNumber.Rd 8ac31d0e05c832f82990ab90d964db43 *man/checkNumeric.Rd 1508713ee4549fc2eadae21a72153e5e *man/checkOS.Rd 38d0ec9b44949c99ddd80579b4f7e303 *man/checkPathForOutput.Rd 44c2a9cd944574c11e711ee0b1f1ec87 *man/checkScalar.Rd 91f057de80081e1aaec589c27cb52ccd *man/checkScalarNA.Rd 234b03a7ac11c373350e40c68b527a67 *man/checkSetEqual.Rd 5e20e2bf82a3574c74c1dfc102ca7a63 *man/checkString.Rd 39432a694e26cf9f9a5dc15d64caf7a6 *man/checkSubset.Rd 62e036129a90eba3ea343b9deecf67cc *man/checkTibble.Rd ba0b9b5fceef00d293a5741c794da380 *man/checkVector.Rd 9937530320d8a2eff40ec40d1f0b2b6d *man/checkmate-package.Rd 999e104b727901446d630de2e97d8491 *man/coalesce.Rd c9a2e0f04386e03e6cfcf4007dbd8ade *man/makeAssertion.Rd 732f8188f436856ffcfb6ddf9e57aa54 *man/makeExpectation.Rd 7e67c63286ad9c675dc9c2e914dfb6ac *man/makeTest.Rd a7ffe767232a4dea7a32c0108b23b42d *man/matchArg.Rd 4443efda93dccea1bc31e0242343b84c *man/qassert.Rd 54ff00ae512007e252569e2864bb43b5 *man/qassertr.Rd 773c91e04a029b6373a7f45a03e92136 *man/vname.Rd 86c9c577e0c85a9e4b12953b428db231 *man/wf.Rd 7364cb13c05a9a9949cf92dfe621bf55 *src/all_missing.c a45e4bb72c61c5b56c40ed0c9c4f8e2d *src/all_missing.h 558e74eba624ee9b62d5d257eba00370 *src/all_nchar.c 05d000d647e2b41ccf98b15ea80ee30f *src/all_nchar.h 9c0140c7ad89352ccd91567fc2e955d7 *src/any_infinite.c 009448e71f30cd62e70c0ecc541dafac *src/any_infinite.h 893a462499191663e9d31e160a48514c *src/any_missing.c 12ca1bba9b80d4831738124f0f44f47a *src/any_missing.h 6bf8d91bdc2a807f3c3311c5af864c32 *src/any_nan.c ee727f245cb4f038f97363dc4774907d *src/any_nan.h fdf494fdb57b43b0dfef772e3c9a7911 *src/checkmate_init.c 767a61939ab1853659f06ad5f041b24a *src/checks.c ac315930c4cf3cc1282261cfa9e31b12 *src/checks.h 4b5f96e9b2eb4ef7d1fc821933ce1c60 *src/guess_type.c ed5f21e3cd4c7ed5977fb8d8a4a60fd9 *src/guess_type.h 830f7df048851f3ef2b11b87b740771a *src/helper.c 05a21400ec5f4885402112b503d7c9b3 *src/helper.h db4e042d2d527f3f5a4f9885ede7c925 *src/is_integerish.c 37a844b2b1e1e911ee04c708eac97d7e *src/is_integerish.h 5a0437d1bc45fe09a2e1f9c95ee6c934 *src/qassert.c cd08a3a5aaa6423ae4a0cfbe9417423e *src/qassert.h 5ef1508b1b9c1a281aa9250e341f91dc *src/which_first.c e2b31960d1f37134ec1a1ea7261f5826 *src/which_first.h 44694bd86ba5d694433561ccfac56fc5 *tests/test-all.R d08cc925e8934c327878bbeb66668234 *tests/testthat/helper.R c74b3874797c89c2ea1cfc9592ffab6e *tests/testthat/test_AssertCollection.R 88a300e6dcc491c577f62eb8d664dcd9 *tests/testthat/test_anyInfinite.R ba67b4d1d4a8943f802f1182e9dcfd42 *tests/testthat/test_anyMissing.R a4cdd9e64bb3ccbb6b6443142960b529 *tests/testthat/test_anyNaN.R 547027ffd3e1ab24d4cfe0c9bd72c260 *tests/testthat/test_asType.R ddaec2c7773e4d847cd1c41ce8747e07 *tests/testthat/test_assert.R 7b1fc897c76160a3e179c3b24148b657 *tests/testthat/test_checkArray.R 52088640fa738f4ab7e657e8b9b4cd02 *tests/testthat/test_checkAtomic.R ad416dbe956f3e6eb38ff46f77a4d8b1 *tests/testthat/test_checkAtomicVector.R 9febffcd26ff60e4a0d383e6e0a8aafb *tests/testthat/test_checkCharacter.R 41d56e1b483893433d81e3da011a6d90 *tests/testthat/test_checkChoice.R f314c946ccfe0bff0d3264925be79716 *tests/testthat/test_checkClass.R 2501bf94e2f24021d01db9931f0f0e5d *tests/testthat/test_checkComplex.R 0bb3a368b5686c4917c154dacc7a3ceb *tests/testthat/test_checkCount.R 23620252e0e5d18793e1a54df4e86f6c *tests/testthat/test_checkDataFrame.R eab5a4c0df22854764a92ccb0a94f4ce *tests/testthat/test_checkDataTable.R 5c5d9baa5e349abd01352fea2271c4c0 *tests/testthat/test_checkDate.R 34c6dc60267982609546dfc50cdc58a5 *tests/testthat/test_checkEnvironment.R d48dcd64af88c011a8b25197d3ac5bdf *tests/testthat/test_checkFactor.R 44fc347e841d8d87fc5a116ec9c32468 *tests/testthat/test_checkFilesystem.R 2ca8bc06283a7c62bdd32f28ccdbda2a *tests/testthat/test_checkFlag.R a62888d365c865a34f1f2b5b5550702b *tests/testthat/test_checkFunction.R e4b3ab35eb4fe35849251783f8151fcd *tests/testthat/test_checkInt.R dad63a92acafbb9d1d9dba9731ffbd0f *tests/testthat/test_checkInteger.R 34e95b11c942a27b1f2935a28d686100 *tests/testthat/test_checkIntegerish.R c79e76785947395d680243b0ab46ec83 *tests/testthat/test_checkList.R edd75ed2d26e8ab74c186bff3511a403 *tests/testthat/test_checkLogical.R a65129dc7218fa3d5c5f0721d0232b51 *tests/testthat/test_checkMatrix.R 518e6fd2f482c4a07c49cab98893528a *tests/testthat/test_checkNamed.R 1f690e6787fd6ce8827b33175e9e91ad *tests/testthat/test_checkNames.R 5ca56038ba855cffb5996db49724663b *tests/testthat/test_checkNull.R 522c310bf5964325aff7e7f94b89c8c8 *tests/testthat/test_checkNumber.R 8990bf7504382c626a46346aed0f920e *tests/testthat/test_checkNumeric.R 9c9459e3ca644bc36cd29bac722ad1b5 *tests/testthat/test_checkOS.R de75d8d474ee541b05666065f39378fd *tests/testthat/test_checkScalar.R 97f0622df0ea56467eecde699a8f5ba6 *tests/testthat/test_checkScalarNA.R d9bd89a962bf68893d16de2c4da40437 *tests/testthat/test_checkSetEqual.R 6165b8f711cf10ac1400c4e0475395e8 *tests/testthat/test_checkString.R 88c672b769859b687cca682373b13fdb *tests/testthat/test_checkSubset.R a055eae13e5682a19c59a85427d5e45b *tests/testthat/test_checkTibble.R 7e3bd43a9d03e3e6156c5f0f3d94a6d6 *tests/testthat/test_checkVector.R 8753de609ab6604b57b1c752ccf6b7d0 *tests/testthat/test_deparse.R 44e25d51ee7e69b021bb6900a89d62ac *tests/testthat/test_guessType.R e73813f27373c2c3449037dca2a36cac *tests/testthat/test_include.R 04a628f6abd687e087711af1ee88868d *tests/testthat/test_interoperability.R bd4632191649731cd59073f4005a4b2c *tests/testthat/test_makeFunction.R a43ada07c4347a5d2ba63dc04d49e5a0 *tests/testthat/test_matchArg.R 52e95aa8ecb54c145d49f0950e5311ac *tests/testthat/test_messages.R 00cbeec1a63a971705a89308f0e2d708 *tests/testthat/test_qassert.R ac5db60f84be6d837df71444b6b1d767 *tests/testthat/test_qassertr.R 98d5ba13378e03edbc92debb3f37772e *tests/testthat/test_wf.R e05bcd2c1512c7632a9607f9632dd5ff *vignettes/checkmate.Rmd checkmate/build/0000755000176200001440000000000013006331417013273 5ustar liggesuserscheckmate/build/vignette.rds0000644000176200001440000000030613006331417015631 0ustar liggesusersb```b`ffd`b2 1# 'MHMM,I MAKI!ter# t0X X%gwI-HK î?"5lP5,n90{C2K7(1 棸(\^Px7@btr$$ Xccheckmate/DESCRIPTION0000644000176200001440000000411513006417455013712 0ustar liggesusersPackage: checkmate Type: Package Title: Fast and Versatile Argument Checks Description: Tests and assertions to perform frequent argument checks. A substantial part of the package was written in C to minimize any worries about execution time overhead. Version: 1.8.2 Authors@R: c( person("Michel", "Lang", NULL, "michellang@gmail.com", role = c("cre", "aut")), person("Bernd", "Bischl", NULL, "bernd_bischl@gmx.de", role = "ctb") ) URL: https://github.com/mllg/checkmate URLNote: https://github.com/mllg/checkmate BugReports: https://github.com/mllg/checkmate/issues NeedsCompilation: yes ByteCompile: yes Encoding: UTF-8 Depends: R (>= 3.0.0) Imports: backports, utils Suggests: data.table, devtools, ggplot2, knitr, rmarkdown, magrittr, microbenchmark, testthat (>= 0.11.0), tibble License: BSD_3_clause + file LICENSE VignetteBuilder: knitr RoxygenNote: 5.0.1 Collate: 'AssertCollection.R' 'allMissing.R' 'anyInfinite.R' 'anyMissing.R' 'anyNaN.R' 'asInteger.R' 'assert.R' 'helper.R' 'makeExpectation.R' 'makeTest.R' 'makeAssertion.R' 'checkAccess.R' 'checkArray.R' 'checkAtomic.R' 'checkAtomicVector.R' 'checkCharacter.R' 'checkChoice.R' 'checkClass.R' 'checkComplex.R' 'checkCount.R' 'checkDataFrame.R' 'checkDataTable.R' 'checkDate.R' 'checkDirectoryExists.R' 'checkEnvironment.R' 'checkFactor.R' 'checkFileExists.R' 'checkFlag.R' 'checkFunction.R' 'checkInt.R' 'checkInteger.R' 'checkIntegerish.R' 'checkList.R' 'checkLogical.R' 'checkMatrix.R' 'checkNamed.R' 'checkNames.R' 'checkNull.R' 'checkNumber.R' 'checkNumeric.R' 'checkOS.R' 'checkPathForOutput.R' 'checkScalar.R' 'checkScalarNA.R' 'checkSetEqual.R' 'checkString.R' 'checkSubset.R' 'checkTibble.R' 'checkVector.R' 'coalesce.R' 'isIntegerish.R' 'matchArg.R' 'qassert.R' 'qassertr.R' 'vname.R' 'wfwl.R' 'zzz.R' Packaged: 2016-11-02 09:34:07 UTC; lang Author: Michel Lang [cre, aut], Bernd Bischl [ctb] Maintainer: Michel Lang Repository: CRAN Date/Publication: 2016-11-02 18:15:25 checkmate/man/0000755000176200001440000000000013006323355012751 5ustar liggesuserscheckmate/man/checkIntegerish.Rd0000644000176200001440000001257412762013206016347 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkIntegerish.R \name{checkIntegerish} \alias{assertIntegerish} \alias{assert_integerish} \alias{checkIntegerish} \alias{check_integerish} \alias{expect_integerish} \alias{testIntegerish} \alias{test_integerish} \title{Check if an object is an integerish vector} \usage{ checkIntegerish(x, tol = sqrt(.Machine$double.eps), lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) check_integerish(x, tol = sqrt(.Machine$double.eps), lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) assertIntegerish(x, tol = sqrt(.Machine$double.eps), lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_integerish(x, tol = sqrt(.Machine$double.eps), lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) testIntegerish(x, tol = sqrt(.Machine$double.eps), lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) test_integerish(x, tol = sqrt(.Machine$double.eps), lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) expect_integerish(x, tol = sqrt(.Machine$double.eps), lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{tol}{[\code{double(1)}]\cr Numerical tolerance used to check whether a double or complex can be converted. Default is \code{sqrt(.Machine$double.eps)}.} \item{lower}{[\code{numeric(1)}]\cr Lower value all elements of \code{x} must be greater than.} \item{upper}{[\code{numeric(1)}]\cr Upper value all elements of \code{x} must be lower than.} \item{any.missing}{[\code{logical(1)}]\cr Are vectors with missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are vectors with only missing values allowed? Default is \code{TRUE}.} \item{len}{[\code{integer(1)}]\cr Exact expected length of \code{x}.} \item{min.len}{[\code{integer(1)}]\cr Minimal length of \code{x}.} \item{max.len}{[\code{integer(1)}]\cr Maximal length of \code{x}.} \item{unique}{[\code{logical(1)}]\cr Must all values be unique? Default is \code{FALSE}.} \item{names}{[\code{character(1)}]\cr Check for names. See \code{\link{checkNamed}} for possible values. Default is \dQuote{any} which performs no check at all. Note that you can use \code{\link{checkSubset}} to check for a specific set of names.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertIntegerish}/\code{assert_integerish} return \code{x} invisibly, whereas \code{checkIntegerish}/\code{check_integerish} and \code{testIntegerish}/\code{test_integerish} return \code{TRUE}. If the check is not successful, \code{assertIntegerish}/\code{assert_integerish} throws an error message, \code{testIntegerish}/\code{test_integerish} returns \code{FALSE}, and \code{checkIntegerish} returns a string with the error message. The function \code{expect_integerish} always returns an \code{\link[testthat]{expectation}}. } \description{ An integerish value is defined as value safely convertible to integer. This includes integers and numeric values which are close to an integer w.r.t. a numeric tolerance. } \details{ This function does not distinguish between \code{NA}, \code{NA_integer_}, \code{NA_real_}, \code{NA_complex_} \code{NA_character_} and \code{NaN}. } \examples{ testIntegerish(1L) testIntegerish(1.) testIntegerish(1:2, lower = 1L, upper = 2L, any.missing = FALSE) } \seealso{ Other basetypes: \code{\link{checkArray}}, \code{\link{checkAtomic}}, \code{\link{checkCharacter}}, \code{\link{checkComplex}}, \code{\link{checkDataFrame}}, \code{\link{checkDate}}, \code{\link{checkEnvironment}}, \code{\link{checkFactor}}, \code{\link{checkFunction}}, \code{\link{checkInteger}}, \code{\link{checkList}}, \code{\link{checkLogical}}, \code{\link{checkMatrix}}, \code{\link{checkNull}}, \code{\link{checkNumeric}}, \code{\link{checkVector}} } checkmate/man/vname.Rd0000644000176200001440000000073212762012005014343 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/vname.R \name{vname} \alias{vname} \title{Lookup a variable name} \usage{ vname(x) } \arguments{ \item{x}{[ANY]\cr Object.} } \value{ [\code{character(1)}] Variable name. } \description{ Tries to heuristically determine the variable name of \code{x} in the parent frame with a combination of \code{\link[base]{deparse}} and \code{\link[base]{substitute}}. Used for checkmate's error messages. } checkmate/man/checkCharacter.Rd0000644000176200001440000001307512762013206016137 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkCharacter.R \name{checkCharacter} \alias{assertCharacter} \alias{assert_character} \alias{checkCharacter} \alias{check_character} \alias{expect_character} \alias{testCharacter} \alias{test_character} \title{Check if an argument is a vector of type character} \usage{ checkCharacter(x, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) check_character(x, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) assertCharacter(x, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_character(x, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) testCharacter(x, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) test_character(x, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) expect_character(x, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{min.chars}{[\code{integer(1)}]\cr Minimum number of characters in each element of \code{x}.} \item{pattern}{[\code{character(1L)}]\cr Regular expression as used in \code{\link[base]{grepl}}. All elements of \code{x} must comply to this pattern.} \item{fixed}{[\code{character(1)}]\cr Substring to detect in \code{x}. Will be used as \code{pattern} in \code{\link[base]{grepl}} with option \code{fixed} set to \code{TRUE}. All elements of \code{x} must contain this substring.} \item{ignore.case}{[\code{logical(1)}]\cr See \code{\link[base]{grepl}}. Default is \code{FALSE}.} \item{any.missing}{[\code{logical(1)}]\cr Are vectors with missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are vectors with only missing values allowed? Default is \code{TRUE}.} \item{len}{[\code{integer(1)}]\cr Exact expected length of \code{x}.} \item{min.len}{[\code{integer(1)}]\cr Minimal length of \code{x}.} \item{max.len}{[\code{integer(1)}]\cr Maximal length of \code{x}.} \item{unique}{[\code{logical(1)}]\cr Must all values be unique? Default is \code{FALSE}.} \item{names}{[\code{character(1)}]\cr Check for names. See \code{\link{checkNamed}} for possible values. Default is \dQuote{any} which performs no check at all. Note that you can use \code{\link{checkSubset}} to check for a specific set of names.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertCharacter}/\code{assert_character} return \code{x} invisibly, whereas \code{checkCharacter}/\code{check_character} and \code{testCharacter}/\code{test_character} return \code{TRUE}. If the check is not successful, \code{assertCharacter}/\code{assert_character} throws an error message, \code{testCharacter}/\code{test_character} returns \code{FALSE}, and \code{checkCharacter} returns a string with the error message. The function \code{expect_character} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a vector of type character } \details{ This function does not distinguish between \code{NA}, \code{NA_integer_}, \code{NA_real_}, \code{NA_complex_} \code{NA_character_} and \code{NaN}. } \examples{ testCharacter(letters, min.len = 1, any.missing = FALSE) testCharacter(letters, min.chars = 2) testCharacter("example", pattern = "xa") } \seealso{ Other basetypes: \code{\link{checkArray}}, \code{\link{checkAtomic}}, \code{\link{checkComplex}}, \code{\link{checkDataFrame}}, \code{\link{checkDate}}, \code{\link{checkEnvironment}}, \code{\link{checkFactor}}, \code{\link{checkFunction}}, \code{\link{checkIntegerish}}, \code{\link{checkInteger}}, \code{\link{checkList}}, \code{\link{checkLogical}}, \code{\link{checkMatrix}}, \code{\link{checkNull}}, \code{\link{checkNumeric}}, \code{\link{checkVector}} } checkmate/man/checkNames.Rd0000644000176200001440000000753212762013206015307 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkNames.R \name{checkNames} \alias{assertNames} \alias{assert_names} \alias{checkNames} \alias{check_names} \alias{expect_names} \alias{testNames} \alias{test_names} \title{Check names to comply to specific rules} \usage{ checkNames(x, type = "named", permutation.of = NULL, subset.of = NULL, identical.to = NULL) check_names(x, type = "named", permutation.of = NULL, subset.of = NULL, identical.to = NULL) assertNames(x, type = "named", permutation.of = NULL, subset.of = NULL, identical.to = NULL, .var.name = vname(x), add = NULL) assert_names(x, type = "named", permutation.of = NULL, subset.of = NULL, identical.to = NULL, .var.name = vname(x), add = NULL) testNames(x, type = "named", permutation.of = NULL, subset.of = NULL, identical.to = NULL) test_names(x, type = "named", permutation.of = NULL, subset.of = NULL, identical.to = NULL) expect_names(x, type = "named", permutation.of = NULL, subset.of = NULL, identical.to = NULL, info = NULL, label = vname(x)) } \arguments{ \item{x}{[\code{character} || \code{NULL}]\cr Names to check using rules defined via \code{type}.} \item{type}{[character(1)]\cr Type of formal check(s) to perform on the names. \dQuote{unnamed} checks \code{x} to be \code{NULL}. \dQuote{named} (default) checks \code{x} for regular names which excludes names to be \code{NA} or empty (\code{""}). \dQuote{unique} additionally tests for non-duplicated names. \dQuote{strict} checks for unique names which comply to R's variable name restrictions. Note that for zero-length \code{x} all these name checks evaluate to \code{TRUE}.} \item{permutation.of}{[\code{character}]\cr Names provided in \code{x} must be a permutation of the set \code{permutation.of}. Duplicated names in \code{permutation.of} are stripped out and duplicated names in \code{x} thus lead to a failed check. Use this argument instead of \code{identical.to} if the order of the names is not relevant.} \item{subset.of}{[\code{character}]\cr Names provided in \code{x} must be subset of the set \code{subset.of}. Use this argument if duplicated names are okay.} \item{identical.to}{[\code{character}]\cr Names provided in \code{x} must be identical to the vector \code{identical.to}. Use this argument instead of \code{permutation.of} if the order of the names is relevant.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertNamed}/\code{assert_named} return \code{x} invisibly, whereas \code{checkNamed}/\code{check_named} and \code{testNamed}/\code{test_named} return \code{TRUE}. If the check is not successful, \code{assertNamed}/\code{assert_named} throws an error message, \code{testNamed}/\code{test_named} returns \code{FALSE}, and \code{checkNamed} returns a string with the error message. The function \code{expect_named} always returns an \code{\link[testthat]{expectation}}. } \description{ Similar to \code{\link{checkNamed}} but you can pass the names directly. } \examples{ x = 1:3 testNames(x, "unnamed") names(x) = letters[1:3] testNames(x, "unique") cn = c("Species", "Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width") assertNames(names(iris), permutation.of = cn) } \seealso{ Other attributes: \code{\link{checkClass}}, \code{\link{checkNamed}} } checkmate/man/qassert.Rd0000644000176200001440000001104312762012005014714 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/qassert.R \name{qassert} \alias{qassert} \alias{qexpect} \alias{qtest} \title{Quick argument checks on (builtin) R types} \usage{ qassert(x, rules, .var.name = vname(x)) qtest(x, rules) qexpect(x, rules, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object the check.} \item{rules}{[\code{character}]\cr Set of rules. See details.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in error messages. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ \code{qassert} throws an \code{R} exception if object \code{x} does not comply to at least one of the \code{rules} and returns the tested object invisibly otherwise. \code{qtest} behaves the same way but returns \code{FALSE} if none of the \code{rules} comply. \code{qexpect} is intended to be inside the unit test framework \code{\link[testthat]{testthat}} and returns an \code{\link[testthat]{expectation}}. } \description{ The provided functions parse rules which allow to express some of the most frequent argument checks by typing just a few letters. } \details{ The rule is specified in up to three parts. \enumerate{ \item{ Class and missingness check. The first letter is an abbreviation for the class. If it is provided uppercase, missing values are prohibited. Supported abbreviations: \tabular{rl}{ \code{[bB]} \tab Bool / logical.\cr \code{[iI]} \tab Integer.\cr \code{[xX]} \tab Integerish (numeric convertible to integer, see \code{\link{checkIntegerish}}).\cr \code{[rR]} \tab Real / double.\cr \code{[cC]} \tab Complex.\cr \code{[nN]} \tab Numeric (integer or double).\cr \code{[sS]} \tab String / character.\cr \code{[fF]} \tab Factor\cr \code{[aA]} \tab Atomic.\cr \code{[vV]} \tab Atomic vector (see \code{\link{checkAtomicVector}}).\cr \code{[lL]} \tab List. Missingness is defined as \code{NULL} element.\cr \code{[mM]} \tab Matrix.\cr \code{[dD]} \tab Data.frame. Missingness is checked recursively on columns.\cr \code{[e]} \tab Environment.\cr \code{[0]} \tab \code{NULL}.\cr \code{[*]} \tab placeholder to allow any type. } Note that the check for missingness does not distinguish between \code{NaN} and \code{NA}. Infinite values are not treated as missing, but can be caught using boundary checks (part 3). } \item{ Length definition. This can be one of \tabular{rl}{ \code{[*]} \tab any length,\cr \code{[?]} \tab length of zero or one,\cr \code{[+]} \tab length of at least one, or\cr \code{[0-9]+} \tab exact length specified as integer. } Preceding the exact length with one of the comparison operators \code{=}/\code{==}, \code{<}, \code{<=}, \code{>=} or \code{>} is also supported. } \item{ Range check as two numbers separated by a comma, enclosed by square brackets (endpoint included) or parentheses (endpoint excluded). For example, \dQuote{[0, 3)} results in \code{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 \code{[0,]} contains \code{Inf}, while \code{[0,)} does not. The same holds for the left (lower) boundary and \code{-Inf}. E.g., the rule \dQuote{N1()} checks for a single finite numeric which is not NA, while \dQuote{N1[)} allows \code{-Inf}. } } } \note{ The functions are inspired by the blog post of Bogumił Kamiński: \url{http://rsnippets.blogspot.de/2013/06/testing-function-agruments-in-gnu-r.html}. The implementation is mostly written in C to minimize the overhead. } \examples{ # logical of length 1 qtest(NA, "b1") # logical of length 1, NA not allowed qtest(NA, "B1") # logical of length 0 or 1, NA not allowed qtest(TRUE, "B?") # numeric with length > 0 qtest(runif(10), "n+") # integer with length > 0, NAs not allowed, all integers >= 0 and < Inf qtest(1:3, "I+[0,)") # either an emtpy list or a character vector with <=5 elements qtest(1, c("l0", "s<=5")) # data frame with at least one column and no missing value in any column qtest(iris, "D+") } \seealso{ \code{\link{qtestr}} and \code{\link{qassertr}} for efficient checks of list elements and data frame columns. } checkmate/man/checkPathForOutput.Rd0000644000176200001440000000540412762012005017020 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkPathForOutput.R \name{checkPathForOutput} \alias{assertPathForOutput} \alias{assert_path_for_output} \alias{checkPathForOutput} \alias{check_path_for_output} \alias{expect_path_for_output} \alias{testPathForOutput} \alias{test_path_for_output} \title{Check if a path is suited for creating an output file} \usage{ checkPathForOutput(x, overwrite = FALSE) check_path_for_output(x, overwrite = FALSE) assertPathForOutput(x, overwrite = FALSE, .var.name = vname(x), add = NULL) assert_path_for_output(x, overwrite = FALSE, .var.name = vname(x), add = NULL) testPathForOutput(x, overwrite = FALSE) test_path_for_output(x, overwrite = FALSE) expect_path_for_output(x, overwrite = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{overwrite}{[\code{logical(1)}]\cr If \code{TRUE}, an existing file in place is allowed if it it is both readable and writeable. Default is \code{FALSE}.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertPathForOutput}/\code{assert_path_for_output} return \code{x} invisibly, whereas \code{checkPathForOutput}/\code{check_path_for_output} and \code{testPathForOutput}/\code{test_path_for_output} return \code{TRUE}. If the check is not successful, \code{assertPathForOutput}/\code{assert_path_for_output} throws an error message, \code{testPathForOutput}/\code{test_path_for_output} returns \code{FALSE}, and \code{checkPathForOutput} returns a string with the error message. The function \code{expect_path_for_output} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if a file path can be safely be used to create a file and write to it. This is checked: \itemize{ \item{Does \code{dirname(x)} exist?} \item{Does no file under path \code{x} exist?} \item{Is \code{dirname(x)} writeable?} } Paths are relative to the current working directory. } \examples{ # Can we create a file in the tempdir? testPathForOutput(file.path(tempdir(), "process.log")) } \seealso{ Other filesystem: \code{\link{checkAccess}}, \code{\link{checkDirectoryExists}}, \code{\link{checkFileExists}} } checkmate/man/makeAssertion.Rd0000644000176200001440000000474312762012005016050 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/makeAssertion.R \name{makeAssertion} \alias{makeAssertion} \alias{makeAssertionFunction} \title{Turn a Check into an Assertion} \usage{ makeAssertion(x, res, var.name, collection) makeAssertionFunction(check.fun, c.fun = NULL, env = parent.frame()) } \arguments{ \item{x}{[any]\cr Object to check.} \item{res}{[\code{TRUE} | \code{character(1)}]\cr The result of a check function: \code{TRUE} for successful checks, and an error message as string otherwise.} \item{var.name}{[\code{character(1)}]\cr The custom name for \code{x} as passed to any \code{assert*} function. Defaults to a heuristic name lookup.} \item{collection}{[\code{\link{AssertCollection}}]\cr If an \code{\link{AssertCollection}} is provided, the error message is stored in it. If \code{NULL}, an exception is raised if \code{res} is not \code{TRUE}.} \item{check.fun}{[\code{function}]\cr Function which checks the input. Must return \code{TRUE} on success and a string with the error message otherwise.} \item{c.fun}{[\code{character(1)}]\cr If not \code{NULL}, instead of calling the function \code{check.fun}, use \code{.Call} to call a C function \dQuote{c.fun} with the identical set of parameters. The C function must be registered as a native symbol, see \code{\link[base]{.Call}}. Useful if \code{check.fun} is just a simple wrapper.} \item{env}{[\code{environment}]\cr The environment of the created function. Default is the \code{\link[base]{parent.frame}}.} } \value{ \code{makeAssertion} invisibly returns the checked object if the check was successful, and an exception is raised (or its message stored in the collection) otherwise. \code{makeAssertionFunction} returns a \code{function}. } \description{ \code{makeAssertion} is the internal function used to evaluate the result of a check and throw an exception if necessary. \code{makeAssertionFunction} can be used to automatically create an assertion function based on a check function (see example). } \examples{ # Simple custom check function checkFalse = function(x) if (!identical(x, FALSE)) "Must be FALSE" else TRUE # Create the respective assert function assertFalse = function(x, .var.name = vname(x), add = NULL) { res = checkFalse(x) makeAssertion(x, res, .var.name, add) } # Alternative: Automatically create such a function assertFalse = makeAssertionFunction(checkFalse) print(assertFalse) } \seealso{ Other CustomConstructors: \code{\link{makeExpectation}}, \code{\link{makeTest}} } checkmate/man/checkArray.Rd0000644000176200001440000000775112762013206015325 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkArray.R \name{checkArray} \alias{assertArray} \alias{assert_array} \alias{checkArray} \alias{check_array} \alias{expect_array} \alias{testArray} \alias{test_array} \title{Check if an argument is an array} \usage{ checkArray(x, mode = NULL, any.missing = TRUE, d = NULL, min.d = NULL, max.d = NULL, null.ok = FALSE) check_array(x, mode = NULL, any.missing = TRUE, d = NULL, min.d = NULL, max.d = NULL, null.ok = FALSE) assertArray(x, mode = NULL, any.missing = TRUE, d = NULL, min.d = NULL, max.d = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_array(x, mode = NULL, any.missing = TRUE, d = NULL, min.d = NULL, max.d = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) testArray(x, mode = NULL, any.missing = TRUE, d = NULL, min.d = NULL, max.d = NULL, null.ok = FALSE) test_array(x, mode = NULL, any.missing = TRUE, d = NULL, min.d = NULL, max.d = NULL, null.ok = FALSE) expect_array(x, mode = NULL, any.missing = TRUE, d = NULL, min.d = NULL, max.d = NULL, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{mode}{[\code{character(1)}]\cr Storage mode of the array. Arrays can hold vectors, i.e. \dQuote{logical}, \dQuote{integer}, \dQuote{integerish}, \dQuote{double}, \dQuote{numeric}, \dQuote{complex}, \dQuote{character} and \dQuote{list}. You can also specify \dQuote{atomic} here to explicitly prohibit lists. Default is \code{NULL} (no check).} \item{any.missing}{[\code{logical(1)}]\cr Are missing values allowed? Default is \code{TRUE}.} \item{d}{[\code{integer(1)}]\cr Exact number of dimensions of array \code{x}. Default is \code{NULL} (no check).} \item{min.d}{[\code{integer(1)}]\cr Minimum number of dimensions of array \code{x}. Default is \code{NULL} (no check).} \item{max.d}{[\code{integer(1)}]\cr Maximum number of dimensions of array \code{x}. Default is \code{NULL} (no check).} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertArray}/\code{assert_array} return \code{x} invisibly, whereas \code{checkArray}/\code{check_array} and \code{testArray}/\code{test_array} return \code{TRUE}. If the check is not successful, \code{assertArray}/\code{assert_array} throws an error message, \code{testArray}/\code{test_array} returns \code{FALSE}, and \code{checkArray} returns a string with the error message. The function \code{expect_array} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is an array } \examples{ checkArray(array(1:27, dim = c(3, 3, 3)), d = 3) } \seealso{ Other basetypes: \code{\link{checkAtomic}}, \code{\link{checkCharacter}}, \code{\link{checkComplex}}, \code{\link{checkDataFrame}}, \code{\link{checkDate}}, \code{\link{checkEnvironment}}, \code{\link{checkFactor}}, \code{\link{checkFunction}}, \code{\link{checkIntegerish}}, \code{\link{checkInteger}}, \code{\link{checkList}}, \code{\link{checkLogical}}, \code{\link{checkMatrix}}, \code{\link{checkNull}}, \code{\link{checkNumeric}}, \code{\link{checkVector}} Other compound: \code{\link{checkDataFrame}}, \code{\link{checkDataTable}}, \code{\link{checkMatrix}}, \code{\link{checkTibble}} } checkmate/man/anyMissing.Rd0000644000176200001440000000252112762012005015354 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/allMissing.R, R/anyMissing.R \name{allMissing} \alias{allMissing} \alias{anyMissing} \title{Check if an object contains missing values} \usage{ allMissing(x) anyMissing(x) } \arguments{ \item{x}{[\code{ANY}]\cr Object to check.} } \value{ [\code{logical(1)}] Returns \code{TRUE} if any (\code{anyMissing}) or all (\code{allMissing}) elements of \code{x} are missing (see details), \code{FALSE} otherwise. } \description{ Supported are atomic types (see \code{\link[base]{is.atomic}}), lists and data frames. Missingness is defined as \code{NA} or \code{NaN} for atomic types and data frame columns, \code{NULL} is defined as missing for lists.\cr \code{allMissing} applied to a \code{data.frame} returns \code{TRUE} if at least one column has only non-missing values. If you want to perform the less frequent check that there is not a single non-missing observation present in the \code{data.frame}, use \code{all(sapply(df, allMissing))} instead. } \examples{ allMissing(1:2) allMissing(c(1, NA)) allMissing(c(NA, NA)) x = data.frame(a = 1:2, b = NA) # Note how allMissing combines the results for data frames: allMissing(x) all(sapply(x, allMissing)) anyMissing(c(1, 1)) anyMissing(c(1, NA)) anyMissing(list(1, NULL)) x = iris x[, "Species"] = NA anyMissing(x) allMissing(x) } checkmate/man/checkString.Rd0000644000176200001440000000732512762013206015512 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkString.R \name{checkString} \alias{assertString} \alias{assert_string} \alias{checkString} \alias{check_string} \alias{expect_string} \alias{testString} \alias{test_string} \title{Check if an argument is a string} \usage{ checkString(x, na.ok = FALSE, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, null.ok = FALSE) check_string(x, na.ok = FALSE, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, null.ok = FALSE) assertString(x, na.ok = FALSE, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_string(x, na.ok = FALSE, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, null.ok = FALSE, .var.name = vname(x), add = NULL) testString(x, na.ok = FALSE, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, null.ok = FALSE) test_string(x, na.ok = FALSE, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, null.ok = FALSE) expect_string(x, na.ok = FALSE, min.chars = NULL, pattern = NULL, fixed = NULL, ignore.case = FALSE, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{na.ok}{[\code{logical(1)}]\cr Are missing values allowed? Default is \code{FALSE}.} \item{min.chars}{[\code{integer(1)}]\cr Minimum number of characters in each element of \code{x}.} \item{pattern}{[\code{character(1L)}]\cr Regular expression as used in \code{\link[base]{grepl}}. All elements of \code{x} must comply to this pattern.} \item{fixed}{[\code{character(1)}]\cr Substring to detect in \code{x}. Will be used as \code{pattern} in \code{\link[base]{grepl}} with option \code{fixed} set to \code{TRUE}. All elements of \code{x} must contain this substring.} \item{ignore.case}{[\code{logical(1)}]\cr See \code{\link[base]{grepl}}. Default is \code{FALSE}.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertString}/\code{assert_string} return \code{x} invisibly, whereas \code{checkString}/\code{check_string} and \code{testString}/\code{test_string} return \code{TRUE}. If the check is not successful, \code{assertString}/\code{assert_string} throws an error message, \code{testString}/\code{test_string} returns \code{FALSE}, and \code{checkString} returns a string with the error message. The function \code{expect_string} always returns an \code{\link[testthat]{expectation}}. } \description{ A string is defined as a scalar character vector. } \details{ This function does not distinguish between \code{NA}, \code{NA_integer_}, \code{NA_real_}, \code{NA_complex_} \code{NA_character_} and \code{NaN}. } \examples{ testString("a") testString(letters) } \seealso{ Other scalars: \code{\link{checkCount}}, \code{\link{checkFlag}}, \code{\link{checkInt}}, \code{\link{checkNumber}}, \code{\link{checkScalarNA}}, \code{\link{checkScalar}} } checkmate/man/assert.Rd0000644000176200001440000000251012762012005014532 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/assert.R \name{assert} \alias{assert} \title{Combine multiple checks into one assertion} \usage{ assert(..., combine = "or", .var.name = NULL) } \arguments{ \item{...}{[any]\cr List of calls to check functions.} \item{combine}{[\code{character(1)}]\cr \dQuote{or} or \dQuote{and} to combine the check functions with an OR or AND, respectively.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in error messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Throws an error if all checks fail and invisibly returns \code{TRUE} otherwise. } \description{ You can call this function with an arbitrary number of of \code{check*} functions, i.e. functions provided by this package or your own functions which return \code{TRUE} on success and the error message as \code{character(1)} otherwise. The resulting assertion is successful, if \code{combine} is \dQuote{or} (default) and at least one check evaluates to \code{TRUE} or \code{combine} is \dQuote{and} and all checks evaluate to \code{TRUE}. Otherwise, \code{assert} throws an informative error message. } \examples{ x = 1:10 assert(checkNull(x), checkInteger(x, any.missing = FALSE)) \dontrun{ x = 1 assert(checkChoice(x, c("a", "b")), checkDataFrame(x)) } } checkmate/man/checkAtomic.Rd0000644000176200001440000000774512762013206015466 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkAtomic.R \name{checkAtomic} \alias{assertAtomic} \alias{assert_atomic} \alias{checkAtomic} \alias{check_atomic} \alias{expect_atomic} \alias{testAtomic} \alias{test_atomic} \title{Check that an argument is an atomic vector} \usage{ checkAtomic(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL) check_atomic(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL) assertAtomic(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, .var.name = vname(x), add = NULL) assert_atomic(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, .var.name = vname(x), add = NULL) testAtomic(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL) test_atomic(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL) expect_atomic(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{any.missing}{[\code{logical(1)}]\cr Are vectors with missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are vectors with only missing values allowed? Default is \code{TRUE}.} \item{len}{[\code{integer(1)}]\cr Exact expected length of \code{x}.} \item{min.len}{[\code{integer(1)}]\cr Minimal length of \code{x}.} \item{max.len}{[\code{integer(1)}]\cr Maximal length of \code{x}.} \item{unique}{[\code{logical(1)}]\cr Must all values be unique? Default is \code{FALSE}.} \item{names}{[\code{character(1)}]\cr Check for names. See \code{\link{checkNamed}} for possible values. Default is \dQuote{any} which performs no check at all. Note that you can use \code{\link{checkSubset}} to check for a specific set of names.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertAtmoic}/\code{assert_atmoic} return \code{x} invisibly, whereas \code{checkAtmoic}/\code{check_atmoic} and \code{testAtmoic}/\code{test_atmoic} return \code{TRUE}. If the check is not successful, \code{assertAtmoic}/\code{assert_atmoic} throws an error message, \code{testAtmoic}/\code{test_atmoic} returns \code{FALSE}, and \code{checkAtmoic} returns a string with the error message. The function \code{expect_atmoic} always returns an \code{\link[testthat]{expectation}}. } \description{ For the definition of \dQuote{atomic}, see \code{\link[base]{is.atomic}}. } \examples{ testAtomic(letters, min.len = 1L, any.missing = FALSE) } \seealso{ Other atomicvector: \code{\link{checkAtomicVector}}, \code{\link{checkVector}} Other basetypes: \code{\link{checkArray}}, \code{\link{checkCharacter}}, \code{\link{checkComplex}}, \code{\link{checkDataFrame}}, \code{\link{checkDate}}, \code{\link{checkEnvironment}}, \code{\link{checkFactor}}, \code{\link{checkFunction}}, \code{\link{checkIntegerish}}, \code{\link{checkInteger}}, \code{\link{checkList}}, \code{\link{checkLogical}}, \code{\link{checkMatrix}}, \code{\link{checkNull}}, \code{\link{checkNumeric}}, \code{\link{checkVector}} } checkmate/man/checkChoice.Rd0000644000176200001440000000453513006324071015433 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkChoice.R \name{checkChoice} \alias{assertChoice} \alias{assert_choice} \alias{checkChoice} \alias{check_choice} \alias{expect_choice} \alias{testChoice} \alias{test_choice} \title{Check if an object is an element of a given set} \usage{ checkChoice(x, choices) check_choice(x, choices) assertChoice(x, choices, .var.name = vname(x), add = NULL) assert_choice(x, choices, .var.name = vname(x), add = NULL) testChoice(x, choices) test_choice(x, choices) expect_choice(x, choices, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{choices}{[\code{atomic}]\cr Set of possible values.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertChoice}/\code{assert_choice} return \code{x} invisibly, whereas \code{checkChoice}/\code{check_choice} and \code{testChoice}/\code{test_choice} return \code{TRUE}. If the check is not successful, \code{assertChoice}/\code{assert_choice} throws an error message, \code{testChoice}/\code{test_choice} returns \code{FALSE}, and \code{checkChoice} returns a string with the error message. The function \code{expect_choice} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an object is an element of a given set } \note{ The object \code{x} must be of the same type as the set w.r.t. \code{\link[base]{typeof}}. Integers and doubles are both treated as numeric. } \examples{ testChoice("x", letters) # x is converted before the comparison if necessary # note that this is subject to change in a future version testChoice(factor("a"), "a") testChoice(1, "1") testChoice(1, as.integer(1)) } \seealso{ Other set: \code{\link{checkSetEqual}}, \code{\link{checkSubset}} } checkmate/man/checkDate.Rd0000644000176200001440000001034212762013206015112 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkDate.R \name{checkDate} \alias{assertDate} \alias{assert_date} \alias{checkDate} \alias{check_date} \alias{expect_date} \alias{testDate} \alias{test_date} \title{Check that an argument is a Date} \usage{ checkDate(x, lower = NULL, upper = NULL, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, null.ok = FALSE) check_date(x, lower = NULL, upper = NULL, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, null.ok = FALSE) assertDate(x, lower = NULL, upper = NULL, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_date(x, lower = NULL, upper = NULL, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, null.ok = FALSE, .var.name = vname(x), add = NULL) testDate(x, lower = NULL, upper = NULL, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, null.ok = FALSE) test_date(x, lower = NULL, upper = NULL, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, null.ok = FALSE) expect_date(x, lower = NULL, upper = NULL, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{lower}{[\code{\link[base]{Date}}]\cr All dates in \code{x} must be after this date. Comparison is done via \code{\link[base]{Ops.Date}}.} \item{upper}{[\code{\link[base]{Date}}]\cr All dates in \code{x} must be before this date. Comparison is done via \code{\link[base]{Ops.Date}}.} \item{any.missing}{[\code{logical(1)}]\cr Are vectors with missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are vectors with only missing values allowed? Default is \code{TRUE}.} \item{len}{[\code{integer(1)}]\cr Exact expected length of \code{x}.} \item{min.len}{[\code{integer(1)}]\cr Minimal length of \code{x}.} \item{max.len}{[\code{integer(1)}]\cr Maximal length of \code{x}.} \item{unique}{[\code{logical(1)}]\cr Must all values be unique? Default is \code{FALSE}.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertAtmoic}/\code{assert_atmoic} return \code{x} invisibly, whereas \code{checkAtmoic}/\code{check_atmoic} and \code{testAtmoic}/\code{test_atmoic} return \code{TRUE}. If the check is not successful, \code{assertAtmoic}/\code{assert_atmoic} throws an error message, \code{testAtmoic}/\code{test_atmoic} returns \code{FALSE}, and \code{checkAtmoic} returns a string with the error message. The function \code{expect_atmoic} always returns an \code{\link[testthat]{expectation}}. } \description{ Checks that an object is of class \code{\link[base]{Date}}. } \seealso{ Other basetypes: \code{\link{checkArray}}, \code{\link{checkAtomic}}, \code{\link{checkCharacter}}, \code{\link{checkComplex}}, \code{\link{checkDataFrame}}, \code{\link{checkEnvironment}}, \code{\link{checkFactor}}, \code{\link{checkFunction}}, \code{\link{checkIntegerish}}, \code{\link{checkInteger}}, \code{\link{checkList}}, \code{\link{checkLogical}}, \code{\link{checkMatrix}}, \code{\link{checkNull}}, \code{\link{checkNumeric}}, \code{\link{checkVector}} } checkmate/man/checkNumeric.Rd0000644000176200001440000001171112762013206015640 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkNumeric.R \name{checkNumeric} \alias{assertNumeric} \alias{assert_numeric} \alias{checkNumeric} \alias{check_numeric} \alias{expect_numeric} \alias{testNumeric} \alias{test_numeric} \title{Check that an argument is a vector of type numeric} \usage{ checkNumeric(x, lower = -Inf, upper = Inf, finite = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) check_numeric(x, lower = -Inf, upper = Inf, finite = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) assertNumeric(x, lower = -Inf, upper = Inf, finite = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_numeric(x, lower = -Inf, upper = Inf, finite = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) testNumeric(x, lower = -Inf, upper = Inf, finite = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) test_numeric(x, lower = -Inf, upper = Inf, finite = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) expect_numeric(x, lower = -Inf, upper = Inf, finite = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{lower}{[\code{numeric(1)}]\cr Lower value all elements of \code{x} must be greater than.} \item{upper}{[\code{numeric(1)}]\cr Upper value all elements of \code{x} must be lower than.} \item{finite}{[\code{logical(1)}]\cr Check for only finite values? Default is \code{FALSE}.} \item{any.missing}{[\code{logical(1)}]\cr Are vectors with missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are vectors with only missing values allowed? Default is \code{TRUE}.} \item{len}{[\code{integer(1)}]\cr Exact expected length of \code{x}.} \item{min.len}{[\code{integer(1)}]\cr Minimal length of \code{x}.} \item{max.len}{[\code{integer(1)}]\cr Maximal length of \code{x}.} \item{unique}{[\code{logical(1)}]\cr Must all values be unique? Default is \code{FALSE}.} \item{names}{[\code{character(1)}]\cr Check for names. See \code{\link{checkNamed}} for possible values. Default is \dQuote{any} which performs no check at all. Note that you can use \code{\link{checkSubset}} to check for a specific set of names.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertNumeric}/\code{assert_numeric} return \code{x} invisibly, whereas \code{checkNumeric}/\code{check_numeric} and \code{testNumeric}/\code{test_numeric} return \code{TRUE}. If the check is not successful, \code{assertNumeric}/\code{assert_numeric} throws an error message, \code{testNumeric}/\code{test_numeric} returns \code{FALSE}, and \code{checkNumeric} returns a string with the error message. The function \code{expect_numeric} always returns an \code{\link[testthat]{expectation}}. } \description{ Check that an argument is a vector of type numeric } \details{ This function does not distinguish between \code{NA}, \code{NA_integer_}, \code{NA_real_}, \code{NA_complex_} \code{NA_character_} and \code{NaN}. } \examples{ testNumeric(1) testNumeric(1, min.len = 1, lower = 0) } \seealso{ Other basetypes: \code{\link{checkArray}}, \code{\link{checkAtomic}}, \code{\link{checkCharacter}}, \code{\link{checkComplex}}, \code{\link{checkDataFrame}}, \code{\link{checkDate}}, \code{\link{checkEnvironment}}, \code{\link{checkFactor}}, \code{\link{checkFunction}}, \code{\link{checkIntegerish}}, \code{\link{checkInteger}}, \code{\link{checkList}}, \code{\link{checkLogical}}, \code{\link{checkMatrix}}, \code{\link{checkNull}}, \code{\link{checkVector}} } checkmate/man/anyNaN.Rd0000644000176200001440000000076512762012005014427 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/anyNaN.R \name{anyNaN} \alias{anyNaN} \title{Check if an object contains NaN values} \usage{ anyNaN(x) } \arguments{ \item{x}{[\code{ANY}]\cr Object to check.} } \value{ [\code{logical(1)}] Returns \code{TRUE} if any element is \code{NaN}. } \description{ Supported are atomic types (see \code{\link[base]{is.atomic}}), lists and data frames. } \examples{ anyNaN(1:10) anyNaN(c(1:10, NaN)) iris[3, 3] = NaN anyNaN(iris) } checkmate/man/checkNull.Rd0000644000176200001440000000354212762013206015153 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkNull.R \name{checkNull} \alias{assertNull} \alias{assert_null} \alias{checkNull} \alias{check_null} \alias{testNull} \alias{test_null} \title{Check if an argument is NULL} \usage{ checkNull(x) check_null(x) assertNull(x, .var.name = vname(x), add = NULL) assert_null(x, .var.name = vname(x), add = NULL) testNull(x) test_null(x) } \arguments{ \item{x}{[any]\cr Object to check.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertNull}/\code{assert_null} return \code{x} invisibly, whereas \code{checkNull}/\code{check_null} and \code{testNull}/\code{test_null} return \code{TRUE}. If the check is not successful, \code{assertNull}/\code{assert_null} throws an error message, \code{testNull}/\code{test_null} returns \code{FALSE}, and \code{checkNull} returns a string with the error message. The function \code{expect_null} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is NULL } \examples{ testNull(NULL) testNull(1) } \seealso{ Other basetypes: \code{\link{checkArray}}, \code{\link{checkAtomic}}, \code{\link{checkCharacter}}, \code{\link{checkComplex}}, \code{\link{checkDataFrame}}, \code{\link{checkDate}}, \code{\link{checkEnvironment}}, \code{\link{checkFactor}}, \code{\link{checkFunction}}, \code{\link{checkIntegerish}}, \code{\link{checkInteger}}, \code{\link{checkList}}, \code{\link{checkLogical}}, \code{\link{checkMatrix}}, \code{\link{checkNumeric}}, \code{\link{checkVector}} } checkmate/man/checkDataFrame.Rd0000644000176200001440000001304412762013206016063 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkDataFrame.R \name{checkDataFrame} \alias{assertDataFrame} \alias{assert_data_frame} \alias{checkDataFrame} \alias{check_data_frame} \alias{expect_data_frame} \alias{testDataFrame} \alias{test_data_frame} \title{Check if an argument is a data frame} \usage{ checkDataFrame(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) check_data_frame(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) assertDataFrame(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_data_frame(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) testDataFrame(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) test_data_frame(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) expect_data_frame(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{types}{[\code{character}]\cr Character vector of class names. Each list element must inherit from at least one of the provided types. The types \dQuote{logical}, \dQuote{integer}, \dQuote{integerish}, \dQuote{double}, \dQuote{numeric}, \dQuote{complex}, \dQuote{character}, \dQuote{factor}, \dQuote{atomic}, \dQuote{vector} \dQuote{atomicvector}, \dQuote{array}, \dQuote{matrix}, \dQuote{list}, \dQuote{function}, \dQuote{environment} and \dQuote{null} are supported. For other types \code{\link[base]{inherits}} is used as a fallback to check \code{x}'s inheritance. Defaults to \code{character(0)} (no check).} \item{any.missing}{[\code{logical(1)}]\cr Are missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are matrices with only missing values allowed? Default is \code{TRUE}.} \item{min.rows}{[\code{integer(1)}]\cr Minimum number of rows.} \item{min.cols}{[\code{integer(1)}]\cr Minimum number of columns.} \item{nrows}{[\code{integer(1)}]\cr Exact number of rows.} \item{ncols}{[\code{integer(1)}]\cr Exact number of columns.} \item{row.names}{[\code{character(1)}]\cr Check for row names. Default is \dQuote{NULL} (no check). See \code{\link{checkNamed}} for possible values. Note that you can use \code{\link{checkSubset}} to check for a specific set of names.} \item{col.names}{[\code{character(1)}]\cr Check for column names. Default is \dQuote{NULL} (no check). See \code{\link{checkNamed}} for possible values. Note that you can use \code{\link{checkSubset}} to test for a specific set of names.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertDataFrame}/\code{assert_data_frame} return \code{x} invisibly, whereas \code{checkDataFrame}/\code{check_data_frame} and \code{testDataFrame}/\code{test_data_frame} return \code{TRUE}. If the check is not successful, \code{assertDataFrame}/\code{assert_data_frame} throws an error message, \code{testDataFrame}/\code{test_data_frame} returns \code{FALSE}, and \code{checkDataFrame} returns a string with the error message. The function \code{expect_data_frame} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a data frame } \examples{ testDataFrame(iris) testDataFrame(iris, types = c("numeric", "factor"), min.rows = 1, col.names = "named") } \seealso{ Other basetypes: \code{\link{checkArray}}, \code{\link{checkAtomic}}, \code{\link{checkCharacter}}, \code{\link{checkComplex}}, \code{\link{checkDate}}, \code{\link{checkEnvironment}}, \code{\link{checkFactor}}, \code{\link{checkFunction}}, \code{\link{checkIntegerish}}, \code{\link{checkInteger}}, \code{\link{checkList}}, \code{\link{checkLogical}}, \code{\link{checkMatrix}}, \code{\link{checkNull}}, \code{\link{checkNumeric}}, \code{\link{checkVector}} Other compound: \code{\link{checkArray}}, \code{\link{checkDataTable}}, \code{\link{checkMatrix}}, \code{\link{checkTibble}} } checkmate/man/matchArg.Rd0000644000176200001440000000213012762012005014755 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/matchArg.R \name{matchArg} \alias{matchArg} \title{Partial Argument Matching} \usage{ matchArg(x, choices, several.ok = FALSE, .var.name = vname(x), add = NULL) } \arguments{ \item{x}{[character]\cr User provided argument to match.} \item{choices}{[character()]\cr Candidates to match \code{x} with.} \item{several.ok}{[logical(1)]\cr If \code{TRUE}, multiple matches are allowed, cf. \code{\link[base]{match.arg}}.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in error messages. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertions. See \code{\link{AssertCollection}}.} } \value{ Subset of \code{choices}. } \description{ This is an extensions to \code{\link[base]{match.arg}} with support for \code{\link{AssertCollection}}. The behaviour is very similar to \code{\link[base]{match.arg}}, except that \code{NULL} is not a valid value for \code{x}. } \examples{ matchArg("k", choices = c("kendall", "pearson")) } checkmate/man/checkDataTable.Rd0000644000176200001440000001301512762013206016056 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkDataTable.R \name{checkDataTable} \alias{assertDataTable} \alias{assert_data_table} \alias{checkDataTable} \alias{check_data_table} \alias{expect_data_table} \alias{testDataTable} \alias{test_data_table} \title{Check if an argument is a data table} \usage{ checkDataTable(x, key = NULL, index = NULL, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) check_data_table(x, key = NULL, index = NULL, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) assertDataTable(x, key = NULL, index = NULL, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_data_table(x, key = NULL, index = NULL, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) testDataTable(x, key = NULL, index = NULL, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) test_data_table(x, key = NULL, index = NULL, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) expect_data_table(x, key = NULL, index = NULL, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{key}{[\code{character}]\cr Expected primary key(s) of the data table.} \item{index}{[\code{character}]\cr Expected secondary key(s) of the data table.} \item{types}{[\code{character}]\cr Character vector of class names. Each list element must inherit from at least one of the provided types. The types \dQuote{logical}, \dQuote{integer}, \dQuote{integerish}, \dQuote{double}, \dQuote{numeric}, \dQuote{complex}, \dQuote{character}, \dQuote{factor}, \dQuote{atomic}, \dQuote{vector} \dQuote{atomicvector}, \dQuote{array}, \dQuote{matrix}, \dQuote{list}, \dQuote{function}, \dQuote{environment} and \dQuote{null} are supported. For other types \code{\link[base]{inherits}} is used as a fallback to check \code{x}'s inheritance. Defaults to \code{character(0)} (no check).} \item{any.missing}{[\code{logical(1)}]\cr Are missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are matrices with only missing values allowed? Default is \code{TRUE}.} \item{min.rows}{[\code{integer(1)}]\cr Minimum number of rows.} \item{min.cols}{[\code{integer(1)}]\cr Minimum number of columns.} \item{nrows}{[\code{integer(1)}]\cr Exact number of rows.} \item{ncols}{[\code{integer(1)}]\cr Exact number of columns.} \item{row.names}{[\code{character(1)}]\cr Check for row names. Default is \dQuote{NULL} (no check). See \code{\link{checkNamed}} for possible values. Note that you can use \code{\link{checkSubset}} to check for a specific set of names.} \item{col.names}{[\code{character(1)}]\cr Check for column names. Default is \dQuote{NULL} (no check). See \code{\link{checkNamed}} for possible values. Note that you can use \code{\link{checkSubset}} to test for a specific set of names.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertDataTable}/\code{assert_data_table} return \code{x} invisibly, whereas \code{checkDataTable}/\code{check_data_table} and \code{testDataTable}/\code{test_data_table} return \code{TRUE}. If the check is not successful, \code{assertDataTable}/\code{assert_data_table} throws an error message, \code{testDataTable}/\code{test_data_table} returns \code{FALSE}, and \code{checkDataTable} returns a string with the error message. The function \code{expect_data_table} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a data table } \examples{ library(data.table) dt = as.data.table(iris) setkeyv(dt, "Species") setkeyv(dt, "Sepal.Length", physical = FALSE) testDataTable(dt) testDataTable(dt, key = "Species", index = "Sepal.Length", any.missing = FALSE) } \seealso{ Other compound: \code{\link{checkArray}}, \code{\link{checkDataFrame}}, \code{\link{checkMatrix}}, \code{\link{checkTibble}} } checkmate/man/checkScalarNA.Rd0000644000176200001440000000463412762013206015670 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkScalarNA.R \name{checkScalarNA} \alias{assertScalarNA} \alias{assert_scalar_na} \alias{checkScalarNA} \alias{check_scalar_na} \alias{expect_scalar_na} \alias{testScalarNA} \alias{test_scalar_na} \title{Check if an argument is a single missing value} \usage{ checkScalarNA(x, null.ok = FALSE) check_scalar_na(x, null.ok = FALSE) assertScalarNA(x, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_scalar_na(x, null.ok = FALSE, .var.name = vname(x), add = NULL) testScalarNA(x, null.ok = FALSE) test_scalar_na(x, null.ok = FALSE) expect_scalar_na(x, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertScalarNA}/\code{assert_scalar_na} return \code{x} invisibly, whereas \code{checkScalarNA}/\code{check_scalar_na} and \code{testScalarNA}/\code{test_scalar_na} return \code{TRUE}. If the check is not successful, \code{assertScalarNA}/\code{assert_scalar_na} throws an error message, \code{testScalarNA}/\code{test_scalar_na} returns \code{FALSE}, and \code{checkScalarNA} returns a string with the error message. The function \code{expect_scalar_na} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a single missing value } \examples{ testScalarNA(1) testScalarNA(NA_real_) testScalarNA(rep(NA, 2)) } \seealso{ Other scalars: \code{\link{checkCount}}, \code{\link{checkFlag}}, \code{\link{checkInt}}, \code{\link{checkNumber}}, \code{\link{checkScalar}}, \code{\link{checkString}} } checkmate/man/checkSetEqual.Rd0000644000176200001440000000525213006324071015761 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkSetEqual.R \name{checkSetEqual} \alias{assertSetEqual} \alias{assert_set_equal} \alias{checkSetEqual} \alias{check_set_equal} \alias{expect_set_equal} \alias{testSetEqual} \alias{test_set_equal} \title{Check if an argument is equal to a given set} \usage{ checkSetEqual(x, y, ordered = FALSE) check_set_equal(x, y, ordered = FALSE) assertSetEqual(x, y, ordered = FALSE, .var.name = vname(x), add = NULL) assert_set_equal(x, y, ordered = FALSE, .var.name = vname(x), add = NULL) testSetEqual(x, y, ordered = FALSE) test_set_equal(x, y, ordered = FALSE) expect_set_equal(x, y, ordered = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{y}{[\code{atomic}]\cr Set to compare with.} \item{ordered}{[\code{logical(1)}]\cr Check \code{x} to have the same length and order as \code{y}, i.e. check using \dQuote{==} while handling \code{NA}s nicely. Default is \code{FALSE}.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertSubset}/\code{assert_subset} return \code{x} invisibly, whereas \code{checkSubset}/\code{check_subset} and \code{testSubset}/\code{test_subset} return \code{TRUE}. If the check is not successful, \code{assertSubset}/\code{assert_subset} throws an error message, \code{testSubset}/\code{test_subset} returns \code{FALSE}, and \code{checkSubset} returns a string with the error message. The function \code{expect_subset} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is equal to a given set } \note{ The object \code{x} must be of the same type as the set w.r.t. \code{\link[base]{typeof}}. Integers and doubles are both treated as numeric. } \examples{ testSetEqual(c("a", "b"), c("a", "b")) testSetEqual(1:3, 1:4) # x is converted before the comparison if necessary # note that this is subject to change in a future version testSetEqual(factor("a"), "a") testSetEqual(1, "1") testSetEqual(1, as.integer(1)) } \seealso{ Other set: \code{\link{checkChoice}}, \code{\link{checkSubset}} } checkmate/man/checkClass.Rd0000644000176200001440000000513012762013206015301 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkClass.R \name{checkClass} \alias{assertClass} \alias{assert_class} \alias{checkClass} \alias{check_class} \alias{expect_class} \alias{testClass} \alias{test_class} \title{Check the class membership of an argument} \usage{ checkClass(x, classes, ordered = FALSE) check_class(x, classes, ordered = FALSE) assertClass(x, classes, ordered = FALSE, .var.name = vname(x), add = NULL) assert_class(x, classes, ordered = FALSE, .var.name = vname(x), add = NULL) testClass(x, classes, ordered = FALSE) test_class(x, classes, ordered = FALSE) expect_class(x, classes, ordered = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{classes}{[\code{character}]\cr Class names to check for inheritance with \code{\link[base]{inherits}}.} \item{ordered}{[\code{logical(1)}]\cr Expect \code{x} to be specialized in provided order. Default is \code{FALSE}.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertClass}/\code{assert_class} return \code{x} invisibly, whereas \code{checkClass}/\code{check_class} and \code{testClass}/\code{test_class} return \code{TRUE}. If the check is not successful, \code{assertClass}/\code{assert_class} throws an error message, \code{testClass}/\code{test_class} returns \code{FALSE}, and \code{checkClass} returns a string with the error message. The function \code{expect_class} always returns an \code{\link[testthat]{expectation}}. } \description{ Check the class membership of an argument } \examples{ # Create an object with classes "foo" and "bar" x = 1 class(x) = c("foo", "bar") # is x of class "foo"? testClass(x, "foo") # is x of class "foo" and "bar"? testClass(x, c("foo", "bar")) # is x of class "foo" or "bar"? \dontrun{ assert( checkClass(x, "foo"), checkClass(x, "bar") ) } # is x most specialized as "bar"? testClass(x, "bar", ordered = TRUE) } \seealso{ Other attributes: \code{\link{checkNamed}}, \code{\link{checkNames}} } checkmate/man/checkCount.Rd0000644000176200001440000000637312762013206015336 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkCount.R \name{checkCount} \alias{assertCount} \alias{assert_count} \alias{checkCount} \alias{check_count} \alias{expect_count} \alias{testCount} \alias{test_count} \title{Check if an argument is a count} \usage{ checkCount(x, na.ok = FALSE, positive = FALSE, tol = sqrt(.Machine$double.eps), null.ok = FALSE) check_count(x, na.ok = FALSE, positive = FALSE, tol = sqrt(.Machine$double.eps), null.ok = FALSE) assertCount(x, na.ok = FALSE, positive = FALSE, tol = sqrt(.Machine$double.eps), null.ok = FALSE, .var.name = vname(x), add = NULL) assert_count(x, na.ok = FALSE, positive = FALSE, tol = sqrt(.Machine$double.eps), null.ok = FALSE, .var.name = vname(x), add = NULL) testCount(x, na.ok = FALSE, positive = FALSE, tol = sqrt(.Machine$double.eps), null.ok = FALSE) test_count(x, na.ok = FALSE, positive = FALSE, tol = sqrt(.Machine$double.eps), null.ok = FALSE) expect_count(x, na.ok = FALSE, positive = FALSE, tol = sqrt(.Machine$double.eps), null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{na.ok}{[\code{logical(1)}]\cr Are missing values allowed? Default is \code{FALSE}.} \item{positive}{[\code{logical(1)}]\cr Must \code{x} be positive (>= 1)? Default is \code{FALSE}, allowing 0.} \item{tol}{[\code{double(1)}]\cr Numerical tolerance used to check whether a double or complex can be converted. Default is \code{sqrt(.Machine$double.eps)}.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertCount}/\code{assert_count} return \code{x} invisibly, whereas \code{checkCount}/\code{check_count} and \code{testCount}/\code{test_count} return \code{TRUE}. If the check is not successful, \code{assertCount}/\code{assert_count} throws an error message, \code{testCount}/\code{test_count} returns \code{FALSE}, and \code{checkCount} returns a string with the error message. The function \code{expect_count} always returns an \code{\link[testthat]{expectation}}. } \description{ A count is defined as non-negative integerish value. } \details{ This function does not distinguish between \code{NA}, \code{NA_integer_}, \code{NA_real_}, \code{NA_complex_} \code{NA_character_} and \code{NaN}. } \examples{ testCount(1) testCount(-1) } \seealso{ Other scalars: \code{\link{checkFlag}}, \code{\link{checkInt}}, \code{\link{checkNumber}}, \code{\link{checkScalarNA}}, \code{\link{checkScalar}}, \code{\link{checkString}} } checkmate/man/checkComplex.Rd0000644000176200001440000001054112762013206015645 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkComplex.R \name{checkComplex} \alias{assertComplex} \alias{assert_complex} \alias{checkComplex} \alias{check_complex} \alias{expect_complex} \alias{testComplex} \alias{test_complex} \title{Check if an argument is a vector of type complex} \usage{ checkComplex(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) check_complex(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) assertComplex(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_complex(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) testComplex(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) test_complex(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) expect_complex(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{any.missing}{[\code{logical(1)}]\cr Are vectors with missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are vectors with only missing values allowed? Default is \code{TRUE}.} \item{len}{[\code{integer(1)}]\cr Exact expected length of \code{x}.} \item{min.len}{[\code{integer(1)}]\cr Minimal length of \code{x}.} \item{max.len}{[\code{integer(1)}]\cr Maximal length of \code{x}.} \item{unique}{[\code{logical(1)}]\cr Must all values be unique? Default is \code{FALSE}.} \item{names}{[\code{character(1)}]\cr Check for names. See \code{\link{checkNamed}} for possible values. Default is \dQuote{any} which performs no check at all. Note that you can use \code{\link{checkSubset}} to check for a specific set of names.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertComplex}/\code{assert_complex} return \code{x} invisibly, whereas \code{checkComplex}/\code{check_complex} and \code{testComplex}/\code{test_complex} return \code{TRUE}. If the check is not successful, \code{assertComplex}/\code{assert_complex} throws an error message, \code{testComplex}/\code{test_complex} returns \code{FALSE}, and \code{checkComplex} returns a string with the error message. The function \code{expect_complex} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a vector of type complex } \details{ This function does not distinguish between \code{NA}, \code{NA_integer_}, \code{NA_real_}, \code{NA_complex_} \code{NA_character_} and \code{NaN}. } \examples{ testComplex(1) testComplex(1+1i) } \seealso{ Other basetypes: \code{\link{checkArray}}, \code{\link{checkAtomic}}, \code{\link{checkCharacter}}, \code{\link{checkDataFrame}}, \code{\link{checkDate}}, \code{\link{checkEnvironment}}, \code{\link{checkFactor}}, \code{\link{checkFunction}}, \code{\link{checkIntegerish}}, \code{\link{checkInteger}}, \code{\link{checkList}}, \code{\link{checkLogical}}, \code{\link{checkMatrix}}, \code{\link{checkNull}}, \code{\link{checkNumeric}}, \code{\link{checkVector}} } checkmate/man/checkInt.Rd0000644000176200001440000000655212762013206014777 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkInt.R \name{checkInt} \alias{assertInt} \alias{assert_int} \alias{checkInt} \alias{check_int} \alias{expect_int} \alias{testInt} \alias{test_int} \title{Check if an argument is a single integerish value} \usage{ checkInt(x, na.ok = FALSE, lower = -Inf, upper = Inf, tol = sqrt(.Machine$double.eps), null.ok = FALSE) check_int(x, na.ok = FALSE, lower = -Inf, upper = Inf, tol = sqrt(.Machine$double.eps), null.ok = FALSE) assertInt(x, na.ok = FALSE, lower = -Inf, upper = Inf, tol = sqrt(.Machine$double.eps), null.ok = FALSE, .var.name = vname(x), add = NULL) assert_int(x, na.ok = FALSE, lower = -Inf, upper = Inf, tol = sqrt(.Machine$double.eps), null.ok = FALSE, .var.name = vname(x), add = NULL) testInt(x, na.ok = FALSE, lower = -Inf, upper = Inf, tol = sqrt(.Machine$double.eps), null.ok = FALSE) test_int(x, na.ok = FALSE, lower = -Inf, upper = Inf, tol = sqrt(.Machine$double.eps), null.ok = FALSE) expect_int(x, na.ok = FALSE, lower = -Inf, upper = Inf, tol = sqrt(.Machine$double.eps), null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{na.ok}{[\code{logical(1)}]\cr Are missing values allowed? Default is \code{FALSE}.} \item{lower}{[\code{numeric(1)}]\cr Lower value all elements of \code{x} must be greater than.} \item{upper}{[\code{numeric(1)}]\cr Upper value all elements of \code{x} must be lower than.} \item{tol}{[\code{double(1)}]\cr Numerical tolerance used to check whether a double or complex can be converted. Default is \code{sqrt(.Machine$double.eps)}.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertInt}/\code{assert_int} return \code{x} invisibly, whereas \code{checkInt}/\code{check_int} and \code{testInt}/\code{test_int} return \code{TRUE}. If the check is not successful, \code{assertInt}/\code{assert_int} throws an error message, \code{testInt}/\code{test_int} returns \code{FALSE}, and \code{checkInt} returns a string with the error message. The function \code{expect_int} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a single integerish value } \details{ This function does not distinguish between \code{NA}, \code{NA_integer_}, \code{NA_real_}, \code{NA_complex_} \code{NA_character_} and \code{NaN}. } \examples{ testInt(1) testInt(-1, lower = 0) } \seealso{ Other scalars: \code{\link{checkCount}}, \code{\link{checkFlag}}, \code{\link{checkNumber}}, \code{\link{checkScalarNA}}, \code{\link{checkScalar}}, \code{\link{checkString}} } checkmate/man/qassertr.Rd0000644000176200001440000000364412762012005015106 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/qassertr.R \name{qassertr} \alias{qassertr} \alias{qexpectr} \alias{qtestr} \title{Quick recursive arguments checks on lists and data frames} \usage{ qassertr(x, rules, .var.name = vname(x)) qtestr(x, rules, depth = 1L) qexpectr(x, rules, info = NULL, label = vname(x)) } \arguments{ \item{x}{[\code{list} or \code{data.frame}]\cr List or data frame to check for compliance with at least one of \code{rules}. See details of \code{\link{qtest}} for rule explanation.} \item{rules}{[\code{character}]\cr Set of rules. See \code{\link{qtest}}} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in error messages. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{depth}{[\code{integer(1)}]\cr Maximum recursion depth. Defaults to \dQuote{1} to directly check list elements or data frame columns. Set to a higher value to check lists of lists of elements.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ See \code{\link{qassert}}. } \description{ These functions are the tuned counterparts of \code{\link{qtest}}, \code{\link{qassert}} and \code{\link{qexpect}} tailored for recursive checks of list elements or data frame columns. } \examples{ # All list elements are integers with length >= 1? qtestr(as.list(1:10), "i+") # All list elements (i.e. data frame columns) are numeric? qtestr(iris, "n") # All list elements are numeric, w/o NAs? qtestr(list(a = 1:3, b = rnorm(1), c = letters), "N+") # All list elements are numeric OR character qtestr(list(a = 1:3, b = rnorm(1), c = letters), c("N+", "S+")) } \seealso{ \code{\link{qtest}}, \code{\link{qassert}} } checkmate/man/checkVector.Rd0000644000176200001440000001115312762013206015500 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkVector.R \name{checkVector} \alias{assertVector} \alias{assert_vector} \alias{checkVector} \alias{check_vector} \alias{expect_vector} \alias{testVector} \alias{test_vector} \title{Check if an argument is a vector} \usage{ checkVector(x, strict = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) check_vector(x, strict = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) assertVector(x, strict = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_vector(x, strict = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) testVector(x, strict = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) test_vector(x, strict = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) expect_vector(x, strict = FALSE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{strict}{[\code{logical(1)}]\cr May the vector have additional attributes or perform a check for additional attributes like \code{\link[base]{is.vector}}? Default is \code{FALSE} which allows e.g. \code{factor}s or \code{data.frame}s to be recognized as vectors.} \item{any.missing}{[\code{logical(1)}]\cr Are vectors with missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are vectors with only missing values allowed? Default is \code{TRUE}.} \item{len}{[\code{integer(1)}]\cr Exact expected length of \code{x}.} \item{min.len}{[\code{integer(1)}]\cr Minimal length of \code{x}.} \item{max.len}{[\code{integer(1)}]\cr Maximal length of \code{x}.} \item{unique}{[\code{logical(1)}]\cr Must all values be unique? Default is \code{FALSE}.} \item{names}{[\code{character(1)}]\cr Check for names. See \code{\link{checkNamed}} for possible values. Default is \dQuote{any} which performs no check at all. Note that you can use \code{\link{checkSubset}} to check for a specific set of names.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertVector}/\code{assert_vector} return \code{x} invisibly, whereas \code{checkVector}/\code{check_vector} and \code{testVector}/\code{test_vector} return \code{TRUE}. If the check is not successful, \code{assertVector}/\code{assert_vector} throws an error message, \code{testVector}/\code{test_vector} returns \code{FALSE}, and \code{checkVector} returns a string with the error message. The function \code{expect_vector} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a vector } \examples{ testVector(letters, min.len = 1L, any.missing = FALSE) } \seealso{ Other atomicvector: \code{\link{checkAtomicVector}}, \code{\link{checkAtomic}} Other basetypes: \code{\link{checkArray}}, \code{\link{checkAtomic}}, \code{\link{checkCharacter}}, \code{\link{checkComplex}}, \code{\link{checkDataFrame}}, \code{\link{checkDate}}, \code{\link{checkEnvironment}}, \code{\link{checkFactor}}, \code{\link{checkFunction}}, \code{\link{checkIntegerish}}, \code{\link{checkInteger}}, \code{\link{checkList}}, \code{\link{checkLogical}}, \code{\link{checkMatrix}}, \code{\link{checkNull}}, \code{\link{checkNumeric}} } checkmate/man/checkEnvironment.Rd0000644000176200001440000000611712762013206016546 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkEnvironment.R \name{checkEnvironment} \alias{assertEnvironment} \alias{assert_environment} \alias{checkEnvironment} \alias{check_environment} \alias{expect_environment} \alias{testEnvironment} \alias{test_environment} \title{Check if an argument is an environment} \usage{ checkEnvironment(x, contains = character(0L), null.ok = FALSE) check_environment(x, contains = character(0L), null.ok = FALSE) assertEnvironment(x, contains = character(0L), null.ok = FALSE, .var.name = vname(x), add = NULL) assert_environment(x, contains = character(0L), null.ok = FALSE, .var.name = vname(x), add = NULL) testEnvironment(x, contains = character(0L), null.ok = FALSE) test_environment(x, contains = character(0L), null.ok = FALSE) expect_environment(x, contains = character(0L), null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{contains}{[\code{character}]\cr Vector of object names expected in the environment. Defaults to \code{character(0)}.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertEnvironment}/\code{assert_environment} return \code{x} invisibly, whereas \code{checkEnvironment}/\code{check_environment} and \code{testEnvironment}/\code{test_environment} return \code{TRUE}. If the check is not successful, \code{assertEnvironment}/\code{assert_environment} throws an error message, \code{testEnvironment}/\code{test_environment} returns \code{FALSE}, and \code{checkEnvironment} returns a string with the error message. The function \code{expect_environment} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is an environment } \examples{ ee = as.environment(list(a = 1)) testEnvironment(ee) testEnvironment(ee, contains = "a") } \seealso{ Other basetypes: \code{\link{checkArray}}, \code{\link{checkAtomic}}, \code{\link{checkCharacter}}, \code{\link{checkComplex}}, \code{\link{checkDataFrame}}, \code{\link{checkDate}}, \code{\link{checkFactor}}, \code{\link{checkFunction}}, \code{\link{checkIntegerish}}, \code{\link{checkInteger}}, \code{\link{checkList}}, \code{\link{checkLogical}}, \code{\link{checkMatrix}}, \code{\link{checkNull}}, \code{\link{checkNumeric}}, \code{\link{checkVector}} } checkmate/man/makeTest.Rd0000644000176200001440000000371012762012005015011 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/makeTest.R \name{makeTest} \alias{makeTest} \alias{makeTestFunction} \title{Turn a Check into a Test} \usage{ makeTest(res) makeTestFunction(check.fun, c.fun = NULL, env = parent.frame()) } \arguments{ \item{res}{[\code{TRUE} | \code{character(1)}]\cr The result of a check function: \code{TRUE} for successful checks, and an error message as string otherwise.} \item{check.fun}{[\code{function}]\cr Function which checks the input. Must return \code{TRUE} on success and a string with the error message otherwise.} \item{c.fun}{[\code{character(1)}]\cr If not \code{NULL}, instead of calling the function \code{check.fun}, use \code{.Call} to call a C function \dQuote{c.fun} with the identical set of parameters. The C function must be registered as a native symbol, see \code{\link[base]{.Call}}. Useful if \code{check.fun} is just a simple wrapper.} \item{env}{[\code{environment}]\cr The environment of the created function. Default is the \code{\link[base]{parent.frame}}.} } \value{ \code{makeTest} returns \code{TRUE} if the check is successful and \code{FALSE} otherwise. \code{makeTestFunction} returns a \code{function}. } \description{ \code{makeTest} is the internal function used to evaluate the result of a check and throw an exception if necessary. This function is currently only a stub and just calls \code{\link[base]{isTRUE}}. \code{makeTestFunction} can be used to automatically create an assertion function based on a check function (see example). } \examples{ # Simple custom check function checkFalse = function(x) if (!identical(x, FALSE)) "Must be FALSE" else TRUE # Create the respective test function testFalse = function(x) { res = checkFalse(x) makeTest(res) } # Alternative: Automatically create such a function testFalse = makeTestFunction(checkFalse) print(testFalse) } \seealso{ Other CustomConstructors: \code{\link{makeAssertion}}, \code{\link{makeExpectation}} } checkmate/man/checkSubset.Rd0000644000176200001440000000523613006324071015505 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkSubset.R \name{checkSubset} \alias{assertSubset} \alias{assert_subset} \alias{checkSubset} \alias{check_subset} \alias{expect_subset} \alias{testSubset} \alias{test_subset} \title{Check if an argument is a subset of a given set} \usage{ checkSubset(x, choices, empty.ok = TRUE) check_subset(x, choices, empty.ok = TRUE) assertSubset(x, choices, empty.ok = TRUE, .var.name = vname(x), add = NULL) assert_subset(x, choices, empty.ok = TRUE, .var.name = vname(x), add = NULL) testSubset(x, choices, empty.ok = TRUE) test_subset(x, choices, empty.ok = TRUE) expect_subset(x, choices, empty.ok = TRUE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{choices}{[\code{atomic}]\cr Set of possible values.} \item{empty.ok}{[\code{logical(1)}]\cr Treat zero-length \code{x} as subset of any set \code{choices}? Default is \code{TRUE}.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertSubset}/\code{assert_subset} return \code{x} invisibly, whereas \code{checkSubset}/\code{check_subset} and \code{testSubset}/\code{test_subset} return \code{TRUE}. If the check is not successful, \code{assertSubset}/\code{assert_subset} throws an error message, \code{testSubset}/\code{test_subset} returns \code{FALSE}, and \code{checkSubset} returns a string with the error message. The function \code{expect_subset} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a subset of a given set } \note{ The object \code{x} must be of the same type as the set w.r.t. \code{\link[base]{typeof}}. Integers and doubles are both treated as numeric. } \examples{ testSubset(c("a", "z"), letters) testSubset("ab", letters) testSubset("Species", names(iris)) # x is converted before the comparison if necessary # note that this is subject to change in a future version testSubset(factor("a"), "a") testSubset(1, "1") testSubset(1, as.integer(1)) } \seealso{ Other set: \code{\link{checkChoice}}, \code{\link{checkSetEqual}} } checkmate/man/checkOS.Rd0000644000176200001440000000343612762012005014560 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkOS.R \name{checkOS} \alias{assertOS} \alias{assert_os} \alias{checkOS} \alias{check_os} \alias{expect_os} \alias{testOS} \alias{test_os} \title{Check the operating system} \usage{ checkOS(os) check_os(os) assertOS(os, add = NULL, .var.name = NULL) assert_os(os, add = NULL, .var.name = NULL) testOS(os) test_os(os) expect_os(os, info = NULL, label = NULL) } \arguments{ \item{os}{[\code{character(1)}]\cr Check the operating system to be in a set with possible elements \dQuote{windows}, \dQuote{mac}, \dQuote{linux} and \dQuote{solaris}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertOS}/\code{assert_os} return \code{x} invisibly, whereas \code{checkOS}/\code{check_os} and \code{testOS}/\code{test_os} return \code{TRUE}. If the check is not successful, \code{assertOS}/\code{assert_os} throws an error message, \code{testOS}/\code{test_os} returns \code{FALSE}, and \code{checkOS} returns a string with the error message. The function \code{expect_os} always returns an \code{\link[testthat]{expectation}}. } \description{ Check the operating system } \examples{ testOS("linux") } checkmate/man/checkmate-package.Rd0000644000176200001440000000465212762013206016563 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/zzz.R \docType{package} \name{checkmate-package} \alias{checkmate} \alias{checkmate-package} \title{Fast and Versatile Argument Checks} \description{ \describe{ \item{Homepage:}{\url{https://github.com/mllg/checkmate}} \item{Bug Reports:}{\url{https://github.com/mllg/checkmate/issues}} } } \section{Overview of implemented functions}{ Check scalars: \itemize{ \item{\code{\link{checkFlag}}} \item{\code{\link{checkCount}}} \item{\code{\link{checkNumber}}} \item{\code{\link{checkInt}}} \item{\code{\link{checkString}}} \item{\code{\link{checkScalar}}} \item{\code{\link{checkScalarNA}}} } Check vectors: \itemize{ \item{\code{\link{checkLogical}}} \item{\code{\link{checkNumeric}}} \item{\code{\link{checkInteger}}} \item{\code{\link{checkIntegerish}}} \item{\code{\link{checkComplex}}} \item{\code{\link{checkFactor}}} \item{\code{\link{checkList}}} \item{\code{\link{checkVector}}} \item{\code{\link{checkAtomic}}} \item{\code{\link{checkAtomicVector}}} } Check attributes: \itemize{ \item{\code{\link{checkClass}}} \item{\code{\link{checkNames}}} \item{\code{\link{checkNamed}}} } Check compound types: \itemize{ \item{\code{\link{checkMatrix}}} \item{\code{\link{checkArray}}} \item{\code{\link{checkDataFrame}}} \item{\code{\link{checkDataTable}}} \item{\code{\link{checkTibble}}} } Check other built-in R types: \itemize{ \item{\code{\link{checkNull}}} \item{\code{\link{checkEnvironment}}} \item{\code{\link{checkFunction}}} \item{\code{\link{checkDate}}} } Check sets: \itemize{ \item{\code{\link{checkChoice}}} \item{\code{\link{checkSubset}}} \item{\code{\link{checkSetEqual}}} } File IO: \itemize{ \item{\code{\link{checkFileExists}}} \item{\code{\link{checkDirectoryExists}}} \item{\code{\link{checkPathForOutput}}} \item{\code{\link{checkAccess}}} } Safe coercion to integer: \itemize{ \item{\code{\link{asCount}}} \item{\code{\link{asInt}}} \item{\code{\link{asInteger}}} } Quick argument checks using a DSL: \itemize{ \item{\code{\link{qassert}}} \item{\code{\link{qassertr}}} } Misc: \itemize{ \item{\code{\link{checkOS}} (check operating system)} \item{\code{\link{assert}} (combine multiple checks into an assertion)} \item{\code{\link{anyMissing}}} \item{\code{\link{allMissing}}} \item{\code{\link{anyNaN}}} \item{\code{\link{wf}} (which.first and which.last)} } } checkmate/man/checkScalar.Rd0000644000176200001440000000523612762013206015450 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkScalar.R \name{checkScalar} \alias{assertScalar} \alias{assert_scalar} \alias{checkScalar} \alias{check_scalar} \alias{expect_scalar} \alias{testScalar} \alias{test_scalar} \title{Check if an argument is a single atomic value} \usage{ checkScalar(x, na.ok = FALSE, null.ok = FALSE) check_scalar(x, na.ok = FALSE, null.ok = FALSE) assertScalar(x, na.ok = FALSE, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_scalar(x, na.ok = FALSE, null.ok = FALSE, .var.name = vname(x), add = NULL) testScalar(x, na.ok = FALSE, null.ok = FALSE) test_scalar(x, na.ok = FALSE, null.ok = FALSE) expect_scalar(x, na.ok = FALSE, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{na.ok}{[\code{logical(1)}]\cr Are missing values allowed? Default is \code{FALSE}.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertScalar}/\code{assert_scalar} return \code{x} invisibly, whereas \code{checkScalar}/\code{check_scalar} and \code{testScalar}/\code{test_scalar} return \code{TRUE}. If the check is not successful, \code{assertScalar}/\code{assert_scalar} throws an error message, \code{testScalar}/\code{test_scalar} returns \code{FALSE}, and \code{checkScalar} returns a string with the error message. The function \code{expect_scalar} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a single atomic value } \details{ This function does not distinguish between \code{NA}, \code{NA_integer_}, \code{NA_real_}, \code{NA_complex_} \code{NA_character_} and \code{NaN}. } \examples{ testScalar(1) testScalar(1:10) } \seealso{ Other scalars: \code{\link{checkCount}}, \code{\link{checkFlag}}, \code{\link{checkInt}}, \code{\link{checkNumber}}, \code{\link{checkScalarNA}}, \code{\link{checkString}} } checkmate/man/checkNumber.Rd0000644000176200001440000000636212762013206015474 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkNumber.R \name{checkNumber} \alias{assertNumber} \alias{assert_number} \alias{checkNumber} \alias{check_number} \alias{expect_number} \alias{testNumber} \alias{test_number} \title{Check if an argument is a single numeric value} \usage{ checkNumber(x, na.ok = FALSE, lower = -Inf, upper = Inf, finite = FALSE, null.ok = FALSE) check_number(x, na.ok = FALSE, lower = -Inf, upper = Inf, finite = FALSE, null.ok = FALSE) assertNumber(x, na.ok = FALSE, lower = -Inf, upper = Inf, finite = FALSE, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_number(x, na.ok = FALSE, lower = -Inf, upper = Inf, finite = FALSE, null.ok = FALSE, .var.name = vname(x), add = NULL) testNumber(x, na.ok = FALSE, lower = -Inf, upper = Inf, finite = FALSE, null.ok = FALSE) test_number(x, na.ok = FALSE, lower = -Inf, upper = Inf, finite = FALSE, null.ok = FALSE) expect_number(x, na.ok = FALSE, lower = -Inf, upper = Inf, finite = FALSE, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{na.ok}{[\code{logical(1)}]\cr Are missing values allowed? Default is \code{FALSE}.} \item{lower}{[\code{numeric(1)}]\cr Lower value all elements of \code{x} must be greater than.} \item{upper}{[\code{numeric(1)}]\cr Upper value all elements of \code{x} must be lower than.} \item{finite}{[\code{logical(1)}]\cr Check for only finite values? Default is \code{FALSE}.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertNumber}/\code{assert_number} return \code{x} invisibly, whereas \code{checkNumber}/\code{check_number} and \code{testNumber}/\code{test_number} return \code{TRUE}. If the check is not successful, \code{assertNumber}/\code{assert_number} throws an error message, \code{testNumber}/\code{test_number} returns \code{FALSE}, and \code{checkNumber} returns a string with the error message. The function \code{expect_number} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a single numeric value } \details{ This function does not distinguish between \code{NA}, \code{NA_integer_}, \code{NA_real_}, \code{NA_complex_} \code{NA_character_} and \code{NaN}. } \examples{ testNumber(1) testNumber(1:2) } \seealso{ Other scalars: \code{\link{checkCount}}, \code{\link{checkFlag}}, \code{\link{checkInt}}, \code{\link{checkScalarNA}}, \code{\link{checkScalar}}, \code{\link{checkString}} } checkmate/man/checkFlag.Rd0000644000176200001440000000512212762013206015106 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkFlag.R \name{checkFlag} \alias{assertFlag} \alias{assert_flag} \alias{checkFlag} \alias{check_flag} \alias{expect_flag} \alias{testFlag} \alias{test_flag} \title{Check if an argument is a flag} \usage{ checkFlag(x, na.ok = FALSE, null.ok = FALSE) check_flag(x, na.ok = FALSE, null.ok = FALSE) assertFlag(x, na.ok = FALSE, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_flag(x, na.ok = FALSE, null.ok = FALSE, .var.name = vname(x), add = NULL) testFlag(x, na.ok = FALSE, null.ok = FALSE) test_flag(x, na.ok = FALSE, null.ok = FALSE) expect_flag(x, na.ok = FALSE, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{na.ok}{[\code{logical(1)}]\cr Are missing values allowed? Default is \code{FALSE}.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertFlag}/\code{assert_flag} return \code{x} invisibly, whereas \code{checkFlag}/\code{check_flag} and \code{testFlag}/\code{test_flag} return \code{TRUE}. If the check is not successful, \code{assertFlag}/\code{assert_flag} throws an error message, \code{testFlag}/\code{test_flag} returns \code{FALSE}, and \code{checkFlag} returns a string with the error message. The function \code{expect_flag} always returns an \code{\link[testthat]{expectation}}. } \description{ A flag is defined as single logical value. } \details{ This function does not distinguish between \code{NA}, \code{NA_integer_}, \code{NA_real_}, \code{NA_complex_} \code{NA_character_} and \code{NaN}. } \examples{ testFlag(TRUE) testFlag(1) } \seealso{ Other scalars: \code{\link{checkCount}}, \code{\link{checkInt}}, \code{\link{checkNumber}}, \code{\link{checkScalarNA}}, \code{\link{checkScalar}}, \code{\link{checkString}} } checkmate/man/checkInteger.Rd0000644000176200001440000001146212762013206015636 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkInteger.R \name{checkInteger} \alias{assertInteger} \alias{assert_integer} \alias{checkInteger} \alias{check_integer} \alias{expect_integer} \alias{testInteger} \alias{test_integer} \title{Check if an argument is vector of type integer} \usage{ checkInteger(x, lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) check_integer(x, lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) assertInteger(x, lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_integer(x, lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) testInteger(x, lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) test_integer(x, lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) expect_integer(x, lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{lower}{[\code{numeric(1)}]\cr Lower value all elements of \code{x} must be greater than.} \item{upper}{[\code{numeric(1)}]\cr Upper value all elements of \code{x} must be lower than.} \item{any.missing}{[\code{logical(1)}]\cr Are vectors with missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are vectors with only missing values allowed? Default is \code{TRUE}.} \item{len}{[\code{integer(1)}]\cr Exact expected length of \code{x}.} \item{min.len}{[\code{integer(1)}]\cr Minimal length of \code{x}.} \item{max.len}{[\code{integer(1)}]\cr Maximal length of \code{x}.} \item{unique}{[\code{logical(1)}]\cr Must all values be unique? Default is \code{FALSE}.} \item{names}{[\code{character(1)}]\cr Check for names. See \code{\link{checkNamed}} for possible values. Default is \dQuote{any} which performs no check at all. Note that you can use \code{\link{checkSubset}} to check for a specific set of names.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertInteger}/\code{assert_integer} return \code{x} invisibly, whereas \code{checkInteger}/\code{check_integer} and \code{testInteger}/\code{test_integer} return \code{TRUE}. If the check is not successful, \code{assertInteger}/\code{assert_integer} throws an error message, \code{testInteger}/\code{test_integer} returns \code{FALSE}, and \code{checkInteger} returns a string with the error message. The function \code{expect_integer} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is vector of type integer } \details{ This function does not distinguish between \code{NA}, \code{NA_integer_}, \code{NA_real_}, \code{NA_complex_} \code{NA_character_} and \code{NaN}. } \examples{ testInteger(1L) testInteger(1.) testInteger(1:2, lower = 1, upper = 2, any.missing = FALSE) } \seealso{ \code{\link{asInteger}} Other basetypes: \code{\link{checkArray}}, \code{\link{checkAtomic}}, \code{\link{checkCharacter}}, \code{\link{checkComplex}}, \code{\link{checkDataFrame}}, \code{\link{checkDate}}, \code{\link{checkEnvironment}}, \code{\link{checkFactor}}, \code{\link{checkFunction}}, \code{\link{checkIntegerish}}, \code{\link{checkList}}, \code{\link{checkLogical}}, \code{\link{checkMatrix}}, \code{\link{checkNull}}, \code{\link{checkNumeric}}, \code{\link{checkVector}} } checkmate/man/checkList.Rd0000644000176200001440000001173712762013206015161 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkList.R \name{checkList} \alias{assertList} \alias{assert_list} \alias{checkList} \alias{check_list} \alias{expect_list} \alias{testList} \alias{test_list} \title{Check if an argument is a list} \usage{ checkList(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) check_list(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) assertList(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_list(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) testList(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) test_list(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) expect_list(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{types}{[\code{character}]\cr Character vector of class names. Each list element must inherit from at least one of the provided types. The types \dQuote{logical}, \dQuote{integer}, \dQuote{integerish}, \dQuote{double}, \dQuote{numeric}, \dQuote{complex}, \dQuote{character}, \dQuote{factor}, \dQuote{atomic}, \dQuote{vector} \dQuote{atomicvector}, \dQuote{array}, \dQuote{matrix}, \dQuote{list}, \dQuote{function}, \dQuote{environment} and \dQuote{null} are supported. For other types \code{\link[base]{inherits}} is used as a fallback to check \code{x}'s inheritance. Defaults to \code{character(0)} (no check).} \item{any.missing}{[\code{logical(1)}]\cr Are vectors with missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are vectors with only missing values allowed? Default is \code{TRUE}.} \item{len}{[\code{integer(1)}]\cr Exact expected length of \code{x}.} \item{min.len}{[\code{integer(1)}]\cr Minimal length of \code{x}.} \item{max.len}{[\code{integer(1)}]\cr Maximal length of \code{x}.} \item{unique}{[\code{logical(1)}]\cr Must all values be unique? Default is \code{FALSE}.} \item{names}{[\code{character(1)}]\cr Check for names. See \code{\link{checkNamed}} for possible values. Default is \dQuote{any} which performs no check at all. Note that you can use \code{\link{checkSubset}} to check for a specific set of names.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{...}{[any]\cr Additional parameters used in a call of \code{\link{checkVector}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertList}/\code{assert_list} return \code{x} invisibly, whereas \code{checkList}/\code{check_list} and \code{testList}/\code{test_list} return \code{TRUE}. If the check is not successful, \code{assertList}/\code{assert_list} throws an error message, \code{testList}/\code{test_list} returns \code{FALSE}, and \code{checkList} returns a string with the error message. The function \code{expect_list} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a list } \examples{ testList(list()) testList(as.list(iris), types = c("numeric", "factor")) } \seealso{ Other basetypes: \code{\link{checkArray}}, \code{\link{checkAtomic}}, \code{\link{checkCharacter}}, \code{\link{checkComplex}}, \code{\link{checkDataFrame}}, \code{\link{checkDate}}, \code{\link{checkEnvironment}}, \code{\link{checkFactor}}, \code{\link{checkFunction}}, \code{\link{checkIntegerish}}, \code{\link{checkInteger}}, \code{\link{checkLogical}}, \code{\link{checkMatrix}}, \code{\link{checkNull}}, \code{\link{checkNumeric}}, \code{\link{checkVector}} } checkmate/man/coalesce.Rd0000644000176200001440000000117712762012005015017 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/coalesce.R \name{\%??\%} \alias{\%??\%} \title{Coalesce operator} \usage{ lhs \%??\% rhs } \arguments{ \item{lhs}{[any]\cr Left hand side of the operator. Is returned if not missing or \code{NULL}.} \item{rhs}{[any]\cr Right hand side of the operator. Is returned if \code{lhs} is missing or \code{NULL}.} } \value{ Either \code{lhs} or \code{rhs}. } \description{ Returns the left hand side if not missing nor \code{NULL}, and the right hand side otherwise. } \examples{ print(NULL \%??\% 1 \%??\% 2) print(names(iris) \%??\% letters[seq_len(ncol(iris))]) } checkmate/man/checkMatrix.Rd0000644000176200001440000001215212762013206015502 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkMatrix.R \name{checkMatrix} \alias{assertMatrix} \alias{assert_matrix} \alias{checkMatrix} \alias{check_matrix} \alias{expect_matrix} \alias{testMatrix} \alias{test_matrix} \title{Check if an argument is a matrix} \usage{ checkMatrix(x, mode = NULL, any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) check_matrix(x, mode = NULL, any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) assertMatrix(x, mode = NULL, any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_matrix(x, mode = NULL, any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) testMatrix(x, mode = NULL, any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) test_matrix(x, mode = NULL, any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) expect_matrix(x, mode = NULL, any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{mode}{[\code{character(1)}]\cr Storage mode of the array. Arrays can hold vectors, i.e. \dQuote{logical}, \dQuote{integer}, \dQuote{integerish}, \dQuote{double}, \dQuote{numeric}, \dQuote{complex}, \dQuote{character} and \dQuote{list}. You can also specify \dQuote{atomic} here to explicitly prohibit lists. Default is \code{NULL} (no check).} \item{any.missing}{[\code{logical(1)}]\cr Are missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are matrices with only missing values allowed? Default is \code{TRUE}.} \item{min.rows}{[\code{integer(1)}]\cr Minimum number of rows.} \item{min.cols}{[\code{integer(1)}]\cr Minimum number of columns.} \item{nrows}{[\code{integer(1)}]\cr Exact number of rows.} \item{ncols}{[\code{integer(1)}]\cr Exact number of columns.} \item{row.names}{[\code{character(1)}]\cr Check for row names. Default is \dQuote{NULL} (no check). See \code{\link{checkNamed}} for possible values. Note that you can use \code{\link{checkSubset}} to check for a specific set of names.} \item{col.names}{[\code{character(1)}]\cr Check for column names. Default is \dQuote{NULL} (no check). See \code{\link{checkNamed}} for possible values. Note that you can use \code{\link{checkSubset}} to test for a specific set of names.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertMatrix}/\code{assert_matrix} return \code{x} invisibly, whereas \code{checkMatrix}/\code{check_matrix} and \code{testMatrix}/\code{test_matrix} return \code{TRUE}. If the check is not successful, \code{assertMatrix}/\code{assert_matrix} throws an error message, \code{testMatrix}/\code{test_matrix} returns \code{FALSE}, and \code{checkMatrix} returns a string with the error message. The function \code{expect_matrix} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a matrix } \examples{ x = matrix(1:9, 3) colnames(x) = letters[1:3] testMatrix(x, nrows = 3, min.cols = 1, col.names = "named") } \seealso{ Other basetypes: \code{\link{checkArray}}, \code{\link{checkAtomic}}, \code{\link{checkCharacter}}, \code{\link{checkComplex}}, \code{\link{checkDataFrame}}, \code{\link{checkDate}}, \code{\link{checkEnvironment}}, \code{\link{checkFactor}}, \code{\link{checkFunction}}, \code{\link{checkIntegerish}}, \code{\link{checkInteger}}, \code{\link{checkList}}, \code{\link{checkLogical}}, \code{\link{checkNull}}, \code{\link{checkNumeric}}, \code{\link{checkVector}} Other compound: \code{\link{checkArray}}, \code{\link{checkDataFrame}}, \code{\link{checkDataTable}}, \code{\link{checkTibble}} } checkmate/man/makeExpectation.Rd0000644000176200001440000000433012762012005016354 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/makeExpectation.R \name{makeExpectation} \alias{makeExpectation} \alias{makeExpectationFunction} \title{Turn a Check into an Expectation} \usage{ makeExpectation(x, res, info, label) makeExpectationFunction(check.fun, c.fun = NULL, env = parent.frame()) } \arguments{ \item{x}{[any]\cr Object to check.} \item{res}{[\code{TRUE} | \code{character(1)}]\cr The result of a check function: \code{TRUE} for successful checks, and an error message as string otherwise.} \item{info}{[\code{character(1)}]\cr See \code{\link[testthat]{expect_that}}} \item{label}{[\code{character(1)}]\cr See \code{\link[testthat]{expect_that}}} \item{check.fun}{[\code{function}]\cr Function which checks the input. Must return \code{TRUE} on success and a string with the error message otherwise.} \item{c.fun}{[\code{character(1)}]\cr If not \code{NULL}, instead of calling the function \code{check.fun}, use \code{.Call} to call a C function \dQuote{c.fun} with the identical set of parameters. The C function must be registered as a native symbol, see \code{\link[base]{.Call}}. Useful if \code{check.fun} is just a simple wrapper.} \item{env}{[\code{environment}]\cr The environment of the created function. Default is the \code{\link[base]{parent.frame}}.} } \value{ \code{makeExpectation} invisibly returns the checked object. \code{makeExpectationFunction} returns a \code{function}. } \description{ \code{makeExpectation} is the internal function used to evaluate the result of a check and turn it into an \code{\link[testthat]{expectation}}. \code{makeExceptionFunction} can be used to automatically create an expectation function based on a check function (see example). } \examples{ # Simple custom check function checkFalse = function(x) if (!identical(x, FALSE)) "Must be FALSE" else TRUE # Create the respective expect function expect_false = function(x, info = NULL, label = vname(x)) { res = checkFalse(x) makeExpectation(x, res, info = info, label = label) } # Alternative: Automatically create such a function expect_false = makeExpectationFunction(checkFalse) print(expect_false) } \seealso{ Other CustomConstructors: \code{\link{makeAssertion}}, \code{\link{makeTest}} } checkmate/man/checkDirectoryExists.Rd0000644000176200001440000000635112762012005017402 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkDirectoryExists.R \name{checkDirectoryExists} \alias{assertDirectory} \alias{assertDirectoryExists} \alias{assert_directory} \alias{assert_directory_exists} \alias{checkDirectory} \alias{checkDirectoryExists} \alias{check_directory_exists} \alias{expect_directory} \alias{expect_directory_exists} \alias{testDirectory} \alias{testDirectoryExists} \alias{test_directory} \alias{test_directory_exists} \title{Check for existence and access rights of directories} \usage{ checkDirectoryExists(x, access = "") check_directory_exists(x, access = "") assertDirectoryExists(x, access = "", .var.name = vname(x), add = NULL) assert_directory_exists(x, access = "", .var.name = vname(x), add = NULL) testDirectoryExists(x, access = "") test_directory_exists(x, access = "") expect_directory_exists(x, access = "", info = NULL, label = vname(x)) checkDirectory(x, access = "") assertDirectory(x, access = "", .var.name = vname(x), add = NULL) assert_directory(x, access = "", .var.name = vname(x), add = NULL) testDirectory(x, access = "") test_directory(x, access = "") expect_directory(x, access = "", info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{access}{[\code{character(1)}]\cr Single string containing possible characters \sQuote{r}, \sQuote{w} and \sQuote{x} to force a check for read, write or execute access rights, respectively. Write and executable rights are not checked on Windows.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertDirectoryExists}/\code{assert_directory_exists} return \code{x} invisibly, whereas \code{checkDirectoryExists}/\code{check_directory_exists} and \code{testDirectoryExists}/\code{test_directory_exists} return \code{TRUE}. If the check is not successful, \code{assertDirectoryExists}/\code{assert_directory_exists} throws an error message, \code{testDirectoryExists}/\code{test_directory_exists} returns \code{FALSE}, and \code{checkDirectoryExists} returns a string with the error message. The function \code{expect_directory_exists} always returns an \code{\link[testthat]{expectation}}. } \description{ Check for existence and access rights of directories } \note{ The functions without the suffix \dQuote{exists} are deprecated and will be removed from the package in a future version due to name clashes. } \examples{ # Is R's home directory readable? testDirectory(R.home(), "r") # Is R's home directory readable and writable? testDirectory(R.home(), "rw") } \seealso{ Other filesystem: \code{\link{checkAccess}}, \code{\link{checkFileExists}}, \code{\link{checkPathForOutput}} } checkmate/man/anyInfinite.Rd0000644000176200001440000000105412762012005015510 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/anyInfinite.R \name{anyInfinite} \alias{anyInfinite} \title{Check if an object contains infinite values} \usage{ anyInfinite(x) } \arguments{ \item{x}{[\code{ANY}]\cr Object to check.} } \value{ [\code{logical(1)}] Returns \code{TRUE} if any element is \code{-Inf} or \code{Inf}. } \description{ Supported are atomic types (see \code{\link[base]{is.atomic}}), lists and data frames. } \examples{ anyInfinite(1:10) anyInfinite(c(1:10, Inf)) iris[3, 3] = Inf anyInfinite(iris) } checkmate/man/checkAtomicVector.Rd0000644000176200001440000001002312763530712016637 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkAtomicVector.R \name{checkAtomicVector} \alias{assertAtomicVector} \alias{assert_atomic_vector} \alias{checkAtomicVector} \alias{check_atomic_vector} \alias{expect_atomic_vector} \alias{testAtomicVector} \alias{test_atomic_vector} \title{Check that an argument is an atomic vector} \usage{ checkAtomicVector(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL) check_atomic_vector(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL) assertAtomicVector(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, .var.name = vname(x), add = NULL) assert_atomic_vector(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, .var.name = vname(x), add = NULL) testAtomicVector(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL) test_atomic_vector(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL) expect_atomic_vector(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{any.missing}{[\code{logical(1)}]\cr Are vectors with missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are vectors with only missing values allowed? Default is \code{TRUE}.} \item{len}{[\code{integer(1)}]\cr Exact expected length of \code{x}.} \item{min.len}{[\code{integer(1)}]\cr Minimal length of \code{x}.} \item{max.len}{[\code{integer(1)}]\cr Maximal length of \code{x}.} \item{unique}{[\code{logical(1)}]\cr Must all values be unique? Default is \code{FALSE}.} \item{names}{[\code{character(1)}]\cr Check for names. See \code{\link{checkNamed}} for possible values. Default is \dQuote{any} which performs no check at all.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertAtomicVector}/\code{assert_atomic_vector} return \code{x} invisibly, whereas \code{checkAtomicVector}/\code{check_atomic_vector} and \code{testAtomicVector}/\code{test_atomic_vector} return \code{TRUE}. If the check is not successful, \code{assertAtomicVector}/\code{assert_atomic_vector} throws an error message, \code{testAtomicVector}/\code{test_atomic_vector} returns \code{FALSE}, and \code{checkAtomicVector} returns a string with the error message. The function \code{expect_atomic_vector} always returns an \code{\link[testthat]{expectation}}. } \description{ An atomic vector is defined slightly different from specifications in \code{\link[base]{is.atomic}} and \code{\link[base]{is.vector}}: An atomic vector is either \code{logical}, \code{integer}, \code{numeric}, \code{complex}, \code{character} or \code{raw} and can have any attributes except a dimension attribute (like matrices). I.e., a \code{factor} is an atomic vector, but a matrix or \code{NULL} are not. In short, this is mostly equivalent to \code{is.atomic(x) && !is.null(x) && is.null(dim(x))}. } \examples{ testAtomicVector(letters, min.len = 1L, any.missing = FALSE) } \seealso{ Other atomicvector: \code{\link{checkAtomic}}, \code{\link{checkVector}} } checkmate/man/checkLogical.Rd0000644000176200001440000001055712762013206015617 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkLogical.R \name{checkLogical} \alias{assertLogical} \alias{assert_logical} \alias{checkLogical} \alias{check_logical} \alias{expect_logical} \alias{testLogical} \alias{test_logical} \title{Check if an argument is a vector of type logical} \usage{ checkLogical(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) check_logical(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) assertLogical(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_logical(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) testLogical(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) test_logical(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE) expect_logical(x, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{any.missing}{[\code{logical(1)}]\cr Are vectors with missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are vectors with only missing values allowed? Default is \code{TRUE}.} \item{len}{[\code{integer(1)}]\cr Exact expected length of \code{x}.} \item{min.len}{[\code{integer(1)}]\cr Minimal length of \code{x}.} \item{max.len}{[\code{integer(1)}]\cr Maximal length of \code{x}.} \item{unique}{[\code{logical(1)}]\cr Must all values be unique? Default is \code{FALSE}.} \item{names}{[\code{character(1)}]\cr Check for names. See \code{\link{checkNamed}} for possible values. Default is \dQuote{any} which performs no check at all. Note that you can use \code{\link{checkSubset}} to check for a specific set of names.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertLogical}/\code{assert_logical} return \code{x} invisibly, whereas \code{checkLogical}/\code{check_logical} and \code{testLogical}/\code{test_logical} return \code{TRUE}. If the check is not successful, \code{assertLogical}/\code{assert_logical} throws an error message, \code{testLogical}/\code{test_logical} returns \code{FALSE}, and \code{checkLogical} returns a string with the error message. The function \code{expect_logical} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a vector of type logical } \details{ This function does not distinguish between \code{NA}, \code{NA_integer_}, \code{NA_real_}, \code{NA_complex_} \code{NA_character_} and \code{NaN}. } \examples{ testLogical(TRUE) testLogical(TRUE, min.len = 1) } \seealso{ Other basetypes: \code{\link{checkArray}}, \code{\link{checkAtomic}}, \code{\link{checkCharacter}}, \code{\link{checkComplex}}, \code{\link{checkDataFrame}}, \code{\link{checkDate}}, \code{\link{checkEnvironment}}, \code{\link{checkFactor}}, \code{\link{checkFunction}}, \code{\link{checkIntegerish}}, \code{\link{checkInteger}}, \code{\link{checkList}}, \code{\link{checkMatrix}}, \code{\link{checkNull}}, \code{\link{checkNumeric}}, \code{\link{checkVector}} } checkmate/man/checkFunction.Rd0000644000176200001440000000670612762013206016033 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkFunction.R \name{checkFunction} \alias{assertFunction} \alias{assert_function} \alias{checkFunction} \alias{check_function} \alias{expect_function} \alias{testFunction} \alias{test_function} \title{Check if an argument is a function} \usage{ checkFunction(x, args = NULL, ordered = FALSE, nargs = NULL, null.ok = FALSE) check_function(x, args = NULL, ordered = FALSE, nargs = NULL, null.ok = FALSE) assertFunction(x, args = NULL, ordered = FALSE, nargs = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_function(x, args = NULL, ordered = FALSE, nargs = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) testFunction(x, args = NULL, ordered = FALSE, nargs = NULL, null.ok = FALSE) test_function(x, args = NULL, ordered = FALSE, nargs = NULL, null.ok = FALSE) expect_function(x, args = NULL, ordered = FALSE, nargs = NULL, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{args}{[\code{character}]\cr Expected formal arguments. Checks that a function has no arguments if set to \code{character(0)}. Default is \code{NULL} (no check).} \item{ordered}{[\code{logical(1)}]\cr Flag whether the arguments provided in \code{args} must be the first \code{length(args)} arguments of the function in the specified order. Default is \code{FALSE}.} \item{nargs}{[\code{integer(1)}]\cr Required number of arguments, without \code{...}. Default is \code{NULL} (no check).} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertFunction}/\code{assert_function} return \code{x} invisibly, whereas \code{checkFunction}/\code{check_function} and \code{testFunction}/\code{test_function} return \code{TRUE}. If the check is not successful, \code{assertFunction}/\code{assert_function} throws an error message, \code{testFunction}/\code{test_function} returns \code{FALSE}, and \code{checkFunction} returns a string with the error message. The function \code{expect_function} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a function } \examples{ testFunction(mean) testFunction(mean, args = "x") } \seealso{ Other basetypes: \code{\link{checkArray}}, \code{\link{checkAtomic}}, \code{\link{checkCharacter}}, \code{\link{checkComplex}}, \code{\link{checkDataFrame}}, \code{\link{checkDate}}, \code{\link{checkEnvironment}}, \code{\link{checkFactor}}, \code{\link{checkIntegerish}}, \code{\link{checkInteger}}, \code{\link{checkList}}, \code{\link{checkLogical}}, \code{\link{checkMatrix}}, \code{\link{checkNull}}, \code{\link{checkNumeric}}, \code{\link{checkVector}} } checkmate/man/AssertCollection.Rd0000644000176200001440000000244212762012005016512 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/AssertCollection.R \name{AssertCollection} \alias{AssertCollection} \alias{makeAssertCollection} \alias{reportAssertions} \title{Collect multiple assertions} \usage{ makeAssertCollection() reportAssertions(collection) } \arguments{ \item{collection}{[\code{AssertCollection}]\cr Object of type \dQuote{AssertCollection} (constructed via \code{makeAssertCollection}).} } \value{ \code{makeAssertCollection()} returns an object of class \dQuote{AssertCollection} and \code{reportCollection} returns invisibly \code{TRUE} if no error is thrown (i.e., no message was collected). } \description{ The function \code{makeAssertCollection()} returns a simple stack-like closure you can pass to all functions of the \code{assert*}-family. All messages get collected and can be reported with \code{reportAssertions()}. Alternatively, you can easily write your own report function or customize the the output of the report function to a certain degree. See the example on how to push custom messages or retrieve all stored messages. } \examples{ x = "a" coll = makeAssertCollection() print(coll$isEmpty()) assertNumeric(x, add = coll) coll$isEmpty() coll$push("Custom error message") coll$getMessages() \dontrun{ reportAssertions(coll) } } checkmate/man/checkTibble.Rd0000644000176200001440000001172512762013206015444 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkTibble.R \name{checkTibble} \alias{assertTibble} \alias{assert_tibble} \alias{checkTibble} \alias{check_tibble} \alias{expect_tibble} \alias{testTibble} \alias{test_tibble} \title{Check if an argument is a tibble} \usage{ checkTibble(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) check_tibble(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) assertTibble(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_tibble(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) testTibble(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) test_tibble(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE) expect_tibble(x, types = character(0L), any.missing = TRUE, all.missing = TRUE, min.rows = NULL, min.cols = NULL, nrows = NULL, ncols = NULL, row.names = NULL, col.names = NULL, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{types}{[\code{character}]\cr Character vector of class names. Each list element must inherit from at least one of the provided types. The types \dQuote{logical}, \dQuote{integer}, \dQuote{integerish}, \dQuote{double}, \dQuote{numeric}, \dQuote{complex}, \dQuote{character}, \dQuote{factor}, \dQuote{atomic}, \dQuote{vector} \dQuote{atomicvector}, \dQuote{array}, \dQuote{matrix}, \dQuote{list}, \dQuote{function}, \dQuote{environment} and \dQuote{null} are supported. For other types \code{\link[base]{inherits}} is used as a fallback to check \code{x}'s inheritance. Defaults to \code{character(0)} (no check).} \item{any.missing}{[\code{logical(1)}]\cr Are missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are matrices with only missing values allowed? Default is \code{TRUE}.} \item{min.rows}{[\code{integer(1)}]\cr Minimum number of rows.} \item{min.cols}{[\code{integer(1)}]\cr Minimum number of columns.} \item{nrows}{[\code{integer(1)}]\cr Exact number of rows.} \item{ncols}{[\code{integer(1)}]\cr Exact number of columns.} \item{row.names}{[\code{character(1)}]\cr Check for row names. Default is \dQuote{NULL} (no check). See \code{\link{checkNamed}} for possible values. Note that you can use \code{\link{checkSubset}} to check for a specific set of names.} \item{col.names}{[\code{character(1)}]\cr Check for column names. Default is \dQuote{NULL} (no check). See \code{\link{checkNamed}} for possible values. Note that you can use \code{\link{checkSubset}} to test for a specific set of names.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertTibble}/\code{assert_tibble} return \code{x} invisibly, whereas \code{checkTibble}/\code{check_tibble} and \code{testTibble}/\code{test_tibble} return \code{TRUE}. If the check is not successful, \code{assertTibble}/\code{assert_tibble} throws an error message, \code{testTibble}/\code{test_tibble} returns \code{FALSE}, and \code{checkTibble} returns a string with the error message. The function \code{expect_tibble} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a tibble } \examples{ library(tibble) x = as_tibble(iris) testTibble(x) testTibble(x, nrow = 150, any.missing = FALSE) } \seealso{ Other compound: \code{\link{checkArray}}, \code{\link{checkDataFrame}}, \code{\link{checkDataTable}}, \code{\link{checkMatrix}} } checkmate/man/wf.Rd0000644000176200001440000000140513004124520013643 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/wfwl.R \name{wf} \alias{wf} \alias{wl} \title{Get the index of the first/last TRUE} \usage{ wf(x, use.names = TRUE) wl(x, use.names = TRUE) } \arguments{ \item{x}{[\code{logical}]\cr Logical vector.} \item{use.names}{[\code{logical(1)}]\cr If \code{TRUE} and \code{x} is named, the result is also named.} } \value{ [\code{integer(1)} | \code{integer(0)}]. Returns the index of the first/last \code{TRUE} value in \code{x} or an empty integer vector if none is found. NAs are ignored. } \description{ A quick C implementation for \dQuote{which.first} (\code{head(which(x), 1)}) and \dQuote{which.last} (\code{tail(which(x), 1)}). } \examples{ wf(c(FALSE, TRUE)) wl(c(FALSE, FALSE)) wf(NA) } checkmate/man/checkAccess.Rd0000644000176200001440000000453712762012005015443 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkAccess.R \name{checkAccess} \alias{assertAccess} \alias{assert_access} \alias{checkAccess} \alias{check_access} \alias{expect_access} \alias{testAccess} \alias{test_access} \title{Check file system access rights} \usage{ checkAccess(x, access = "") check_access(x, access = "") assertAccess(x, access = "", .var.name = vname(x), add = NULL) assert_access(x, access = "", .var.name = vname(x), add = NULL) testAccess(x, access = "") test_access(x, access = "") expect_access(x, access = "", info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{access}{[\code{character(1)}]\cr Single string containing possible characters \sQuote{r}, \sQuote{w} and \sQuote{x} to force a check for read, write or execute access rights, respectively. Write and executable rights are not checked on Windows.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertAccess}/\code{assert_access} return \code{x} invisibly, whereas \code{checkAccess}/\code{check_access} and \code{testAccess}/\code{test_access} return \code{TRUE}. If the check is not successful, \code{assertAccess}/\code{assert_access} throws an error message, \code{testAccess}/\code{test_access} returns \code{FALSE}, and \code{checkAccess} returns a string with the error message. The function \code{expect_access} always returns an \code{\link[testthat]{expectation}}. } \description{ Check file system access rights } \examples{ # Is R's home directory readable? testAccess(R.home(), "r") # Is R's home directory writeable? testAccess(R.home(), "w") } \seealso{ Other filesystem: \code{\link{checkDirectoryExists}}, \code{\link{checkFileExists}}, \code{\link{checkPathForOutput}} } checkmate/man/asInteger.Rd0000644000176200001440000000525312762012005015161 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/asInteger.R \name{asInteger} \alias{asCount} \alias{asInt} \alias{asInteger} \title{Convert an argument to an integer} \usage{ asInteger(x, tol = sqrt(.Machine$double.eps), lower = -Inf, upper = Inf, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, unique = FALSE, names = NULL, .var.name = vname(x)) asCount(x, na.ok = FALSE, positive = FALSE, tol = sqrt(.Machine$double.eps), .var.name = vname(x)) asInt(x, na.ok = FALSE, lower = -Inf, upper = Inf, tol = sqrt(.Machine$double.eps), .var.name = vname(x)) } \arguments{ \item{x}{[any]\cr Object to convert.} \item{tol}{[\code{double(1)}]\cr Numerical tolerance used to check whether a double or complex can be converted. Default is \code{sqrt(.Machine$double.eps)}.} \item{lower}{[\code{numeric(1)}]\cr Lower value all elements of \code{x} must be greater than.} \item{upper}{[\code{numeric(1)}]\cr Upper value all elements of \code{x} must be lower than.} \item{any.missing}{[\code{logical(1)}]\cr Are vectors with missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are vectors with only missing values allowed? Default is \code{TRUE}.} \item{len}{[\code{integer(1)}]\cr Exact expected length of \code{x}.} \item{min.len}{[\code{integer(1)}]\cr Minimal length of \code{x}.} \item{max.len}{[\code{integer(1)}]\cr Maximal length of \code{x}.} \item{unique}{[\code{logical(1)}]\cr Must all values be unique? Default is \code{FALSE}.} \item{names}{[\code{character(1)}]\cr Check for names. See \code{\link{checkNamed}} for possible values. Default is \dQuote{any} which performs no check at all. Note that you can use \code{\link{checkSubset}} to check for a specific set of names.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in error messages. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{na.ok}{[\code{logical(1)}]\cr Are missing values allowed? Default is \code{FALSE}.} \item{positive}{[\code{logical(1)}]\cr Must \code{x} be positive (>= 1)? Default is \code{FALSE}.} } \value{ Converted \code{x}. } \description{ \code{asInteger} is intended to be used for vectors while \code{asInt} is a specialization for scalar integers and \code{asCount} for scalar non-negative integers. Convertible are (a) atomic vectors with all elements \code{NA} and (b) double vectors with all elements being within \code{tol} range of an integer. } \details{ This function does not distinguish between \code{NA}, \code{NA_integer_}, \code{NA_real_}, \code{NA_complex_} \code{NA_character_} and \code{NaN}. } \examples{ asInteger(c(1, 2, 3)) asCount(1) asInt(1) } checkmate/man/checkFileExists.Rd0000644000176200001440000000665112762012005016320 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkFileExists.R \name{checkFileExists} \alias{assertFile} \alias{assertFileExists} \alias{assert_file} \alias{assert_file_exists} \alias{checkFile} \alias{checkFileExists} \alias{check_file_exists} \alias{expect_file} \alias{expect_file_exists} \alias{testFile} \alias{testFileExists} \alias{test_file_exists} \title{Check existence and access rights of files} \usage{ checkFileExists(x, access = "", extension = NULL) check_file_exists(x, access = "", extension = NULL) assertFileExists(x, access = "", extension = NULL, .var.name = vname(x), add = NULL) assert_file_exists(x, access = "", extension = NULL, .var.name = vname(x), add = NULL) testFileExists(x, access = "", extension = NULL) test_file_exists(x, access = "", extension = NULL) expect_file_exists(x, access = "", extension = NULL, info = NULL, label = vname(x)) checkFile(x, access = "", extension = NULL) assertFile(x, access = "", extension = NULL, .var.name = vname(x), add = NULL) assert_file(x, access = "", extension = NULL, .var.name = vname(x), add = NULL) testFile(x, access = "", extension = NULL) expect_file(x, access = "", extension = NULL, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{access}{[\code{character(1)}]\cr Single string containing possible characters \sQuote{r}, \sQuote{w} and \sQuote{x} to force a check for read, write or execute access rights, respectively. Write and executable rights are not checked on Windows.} \item{extension}{[\code{character}]\cr Vector of allowed file extensions, matched case insensitive.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertFileExists}/\code{assert_file_exists} return \code{x} invisibly, whereas \code{checkFileExists}/\code{check_file_exists} and \code{testFileExists}/\code{test_file_exists} return \code{TRUE}. If the check is not successful, \code{assertFileExists}/\code{assert_file_exists} throws an error message, \code{testFileExists}/\code{test_file_exists} returns \code{FALSE}, and \code{checkFileExists} returns a string with the error message. The function \code{expect_file_exists} always returns an \code{\link[testthat]{expectation}}. } \description{ Check existence and access rights of files } \note{ The functions without the suffix \dQuote{exists} are deprecated and will be removed from the package in a future version due to name clashes. \code{test_file} has been unexported already. } \examples{ # Check if R's COPYING file is readable testFileExists(file.path(R.home(), "COPYING"), access = "r") # Check if R's COPYING file is readable and writable testFileExists(file.path(R.home(), "COPYING"), access = "rw") } \seealso{ Other filesystem: \code{\link{checkAccess}}, \code{\link{checkDirectoryExists}}, \code{\link{checkPathForOutput}} } checkmate/man/checkFactor.Rd0000644000176200001440000001324612762013206015461 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkFactor.R \name{checkFactor} \alias{assertFactor} \alias{assert_factor} \alias{checkFactor} \alias{check_factor} \alias{expect_factor} \alias{testFactor} \alias{test_factor} \title{Check if an argument is a factor} \usage{ checkFactor(x, levels = NULL, ordered = NA, empty.levels.ok = TRUE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, n.levels = NULL, min.levels = NULL, max.levels = NULL, unique = FALSE, names = NULL, null.ok = FALSE) check_factor(x, levels = NULL, ordered = NA, empty.levels.ok = TRUE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, n.levels = NULL, min.levels = NULL, max.levels = NULL, unique = FALSE, names = NULL, null.ok = FALSE) assertFactor(x, levels = NULL, ordered = NA, empty.levels.ok = TRUE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, n.levels = NULL, min.levels = NULL, max.levels = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) assert_factor(x, levels = NULL, ordered = NA, empty.levels.ok = TRUE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, n.levels = NULL, min.levels = NULL, max.levels = NULL, unique = FALSE, names = NULL, null.ok = FALSE, .var.name = vname(x), add = NULL) testFactor(x, levels = NULL, ordered = NA, empty.levels.ok = TRUE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, n.levels = NULL, min.levels = NULL, max.levels = NULL, unique = FALSE, names = NULL, null.ok = FALSE) test_factor(x, levels = NULL, ordered = NA, empty.levels.ok = TRUE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, n.levels = NULL, min.levels = NULL, max.levels = NULL, unique = FALSE, names = NULL, null.ok = FALSE) expect_factor(x, levels = NULL, ordered = NA, empty.levels.ok = TRUE, any.missing = TRUE, all.missing = TRUE, len = NULL, min.len = NULL, max.len = NULL, n.levels = NULL, min.levels = NULL, max.levels = NULL, unique = FALSE, names = NULL, null.ok = FALSE, info = NULL, label = vname(x)) } \arguments{ \item{x}{[any]\cr Object to check.} \item{levels}{[\code{character}]\cr Vector of allowed factor levels.} \item{ordered}{[\code{logical(1)}]\cr Check for an ordered factor? If \code{FALSE} or \code{TRUE}, checks explicitly for an unordered or ordered factor, respectively. Default is \code{NA} which does not perform any additional check.} \item{empty.levels.ok}{[\code{logical(1)}]\cr Are empty levels allowed? Default is \code{TRUE}.} \item{any.missing}{[\code{logical(1)}]\cr Are vectors with missing values allowed? Default is \code{TRUE}.} \item{all.missing}{[\code{logical(1)}]\cr Are vectors with only missing values allowed? Default is \code{TRUE}.} \item{len}{[\code{integer(1)}]\cr Exact expected length of \code{x}.} \item{min.len}{[\code{integer(1)}]\cr Minimal length of \code{x}.} \item{max.len}{[\code{integer(1)}]\cr Maximal length of \code{x}.} \item{n.levels}{[\code{integer(1)}]\cr Exact number of factor levels. Default is \code{NULL} (no check).} \item{min.levels}{[\code{integer(1)}]\cr Minimum number of factor levels. Default is \code{NULL} (no check).} \item{max.levels}{[\code{integer(1)}]\cr Maximum number of factor levels. Default is \code{NULL} (no check).} \item{unique}{[\code{logical(1)}]\cr Must all values be unique? Default is \code{FALSE}.} \item{names}{[\code{character(1)}]\cr Check for names. See \code{\link{checkNamed}} for possible values. Default is \dQuote{any} which performs no check at all. Note that you can use \code{\link{checkSubset}} to check for a specific set of names.} \item{null.ok}{[\code{logical(1)}]\cr If set to \code{TRUE}, \code{x} may also be \code{NULL}. In this case only a type check of \code{x} is performed, all additional checks are disabled.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} \item{info}{[character(1)]\cr Extra information to be included in the message for the testthat reporter. See \code{\link[testthat]{expect_that}}.} \item{label}{[\code{character(1)}]\cr Name of the checked object to print in messages. Defaults to the heuristic implemented in \code{\link{vname}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertFactor}/\code{assert_factor} return \code{x} invisibly, whereas \code{checkFactor}/\code{check_factor} and \code{testFactor}/\code{test_factor} return \code{TRUE}. If the check is not successful, \code{assertFactor}/\code{assert_factor} throws an error message, \code{testFactor}/\code{test_factor} returns \code{FALSE}, and \code{checkFactor} returns a string with the error message. The function \code{expect_factor} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is a factor } \examples{ x = factor("a", levels = c("a", "b")) testFactor(x) testFactor(x, empty.levels.ok = FALSE) } \seealso{ Other basetypes: \code{\link{checkArray}}, \code{\link{checkAtomic}}, \code{\link{checkCharacter}}, \code{\link{checkComplex}}, \code{\link{checkDataFrame}}, \code{\link{checkDate}}, \code{\link{checkEnvironment}}, \code{\link{checkFunction}}, \code{\link{checkIntegerish}}, \code{\link{checkInteger}}, \code{\link{checkList}}, \code{\link{checkLogical}}, \code{\link{checkMatrix}}, \code{\link{checkNull}}, \code{\link{checkNumeric}}, \code{\link{checkVector}} } checkmate/man/checkNamed.Rd0000644000176200001440000000427112762013206015265 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/checkNamed.R \name{checkNamed} \alias{assertNamed} \alias{assert_named} \alias{checkNamed} \alias{check_named} \alias{testNamed} \alias{test_named} \title{Check if an argument is named} \usage{ checkNamed(x, type = "named") check_named(x, type = "named") assertNamed(x, type = "named", .var.name = vname(x), add = NULL) assert_named(x, type = "named", .var.name = vname(x), add = NULL) testNamed(x, type = "named") test_named(x, type = "named") } \arguments{ \item{x}{[any]\cr Object to check.} \item{type}{[character(1)]\cr Select the check(s) to perform. \dQuote{unnamed} checks \code{x} to be unnamed. \dQuote{named} (default) checks \code{x} to be named which excludes names to be \code{NA} or empty (\code{""}). \dQuote{unique} additionally tests for non-duplicated names. \dQuote{strict} checks for unique names which comply to R's variable name restrictions. Note that for zero-length \code{x} every name check evaluates to \code{TRUE}.} \item{.var.name}{[\code{character(1)}]\cr Name of the checked object to print in assertions. Defaults to the heuristic implemented in \code{\link{vname}}.} \item{add}{[\code{AssertCollection}]\cr Collection to store assertion messages. See \code{\link{AssertCollection}}.} } \value{ Depending on the function prefix: If the check is successful, the functions \code{assertNamed}/\code{assert_named} return \code{x} invisibly, whereas \code{checkNamed}/\code{check_named} and \code{testNamed}/\code{test_named} return \code{TRUE}. If the check is not successful, \code{assertNamed}/\code{assert_named} throws an error message, \code{testNamed}/\code{test_named} returns \code{FALSE}, and \code{checkNamed} returns a string with the error message. The function \code{expect_named} always returns an \code{\link[testthat]{expectation}}. } \description{ Check if an argument is named } \note{ These function are deprecated and will be removed in a future version. Please use \code{\link{checkNames}} instead. } \examples{ x = 1:3 testNamed(x, "unnamed") names(x) = letters[1:3] testNamed(x, "unique") } \seealso{ Other attributes: \code{\link{checkClass}}, \code{\link{checkNames}} } checkmate/LICENSE0000644000176200001440000000011612762012005013174 0ustar liggesusersYEAR: 2016 COPYRIGHT HOLDER: Michel Lang ORGANIZATION: TU Dortmund University