An integerish value is defined as value safely convertible to integer. This includes integers and numeric values which sufficiently close to an integer w.r.t. a numeric tolerance `tol`.

```
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,
sorted = FALSE,
names = NULL,
typed.missing = FALSE,
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,
sorted = FALSE,
names = NULL,
typed.missing = FALSE,
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,
sorted = FALSE,
names = NULL,
typed.missing = FALSE,
null.ok = FALSE,
coerce = 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,
sorted = FALSE,
names = NULL,
typed.missing = FALSE,
null.ok = FALSE,
coerce = 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,
sorted = FALSE,
names = NULL,
typed.missing = FALSE,
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,
sorted = FALSE,
names = NULL,
typed.missing = FALSE,
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,
sorted = FALSE,
names = NULL,
typed.missing = FALSE,
null.ok = FALSE,
info = NULL,
label = vname(x)
)
```

- x
[any]

Object to check.- tol
[

`double(1)`

]

Numerical tolerance used to check whether a double or complex can be converted. Default is`sqrt(.Machine$double.eps)`

.- lower
[

`numeric(1)`

]

Lower value all elements of`x`

must be greater than or equal to.- upper
[

`numeric(1)`

]

Upper value all elements of`x`

must be lower than or equal to.- any.missing
[

`logical(1)`

]

Are vectors with missing values allowed? Default is`TRUE`

.- all.missing
[

`logical(1)`

]

Are vectors with no non-missing values allowed? Default is`TRUE`

. Note that empty vectors do not have non-missing values.- len
[

`integer(1)`

]

Exact expected length of`x`

.- min.len
[

`integer(1)`

]

Minimal length of`x`

.- max.len
[

`integer(1)`

]

Maximal length of`x`

.- unique
[

`logical(1)`

]

Must all values be unique? Default is`FALSE`

.- sorted
[

`logical(1)`

]

Elements must be sorted in ascending order. Missing values are ignored.- names
[

`character(1)`

]

Check for names. See`checkNamed`

for possible values. Default is “any” which performs no check at all. Note that you can use`checkSubset`

to check for a specific set of names.- typed.missing
[

`logical(1)`

]

If set to`FALSE`

(default), all types of missing values (`NA`

,`NA_integer_`

,`NA_real_`

,`NA_character_`

or`NA_character_`

) as well as empty vectors are allowed while type-checking atomic input. Set to`TRUE`

to enable strict type checking.- null.ok
[

`logical(1)`

]

If set to`TRUE`

,`x`

may also be`NULL`

. In this case only a type check of`x`

is performed, all additional checks are disabled.- coerce
[

`logical(1)`

]

If`TRUE`

, the input`x`

is returned as integer after an successful assertion.- .var.name
[

`character(1)`

]

Name of the checked object to print in assertions. Defaults to the heuristic implemented in`vname`

.- add
[

`AssertCollection`

]

Collection to store assertion messages. See`AssertCollection`

.- info
[

`character(1)`

]

Extra information to be included in the message for the testthat reporter. See`expect_that`

.- label
[

`character(1)`

]

Name of the checked object to print in messages. Defaults to the heuristic implemented in`vname`

.

Depending on the function prefix: If the check is successful, the functions

`assertIntegerish`

/`assert_integerish`

return

`x`

invisibly, whereas

`checkIntegerish`

/`check_integerish`

and

`testIntegerish`

/`test_integerish`

return

`TRUE`

.
If the check is not successful,

`assertIntegerish`

/`assert_integerish`

throws an error message,

`testIntegerish`

/`test_integerish`

returns `FALSE`

,
and `checkIntegerish`

/`check_integerish`

return a string with the error message.
The function `expect_integerish`

always returns an

This function does not distinguish between
`NA`

, `NA_integer_`

, `NA_real_`

, `NA_complex_`

`NA_character_`

and `NaN`

.

To convert from integerish to integer, use `asInteger`

.

Other basetypes:
`checkArray()`

,
`checkAtomicVector()`

,
`checkAtomic()`

,
`checkCharacter()`

,
`checkComplex()`

,
`checkDataFrame()`

,
`checkDate()`

,
`checkDouble()`

,
`checkEnvironment()`

,
`checkFactor()`

,
`checkFormula()`

,
`checkFunction()`

,
`checkInteger()`

,
`checkList()`

,
`checkLogical()`

,
`checkMatrix()`

,
`checkNull()`

,
`checkNumeric()`

,
`checkPOSIXct()`

,
`checkRaw()`

,
`checkVector()`

```
testIntegerish(1L)
#> [1] TRUE
testIntegerish(1.)
#> [1] TRUE
testIntegerish(1:2, lower = 1L, upper = 2L, any.missing = FALSE)
#> [1] TRUE
```