tests/testthat/test-introspectors.R

In jeanmathieupotvin/dotprofile: Create and Manage Configuration Profiles

# is_nul() ---------------------------------------------------------------------


test_that("is_nul() works", {
    expect_true(is_nul(NULL))
    expect_false(is_nul(1L))
})


# is_lgl() ---------------------------------------------------------------------


test_that("is_lgl() only checks type only when `n` is null", {
    expect_true(is_lgl(logical(1L)))
    expect_true(is_lgl(logical(2L)))
    expect_false(is_lgl(integer(1L)))
    expect_false(is_lgl(integer(2L)))
})

test_that("is_lgl() also checks length when `n` is not null", {
    expect_true(is_lgl(logical(1L),  1L))
    expect_true(is_lgl(logical(2L),  2L))
    expect_false(is_lgl(integer(2L), 2L))
})

test_that("is_lgl() coerces `n` when it is not an integer", {
    expect_true(is_lgl(logical(1L), "1"))
})

test_that("is_lgl() checks for na values when `.na` is false", {
    expect_true(is_lgl(NA,           NULL, TRUE))
    expect_false(is_lgl(NA,          NULL, FALSE))
    expect_false(is_lgl(c(TRUE, NA), 2L,   FALSE))
})


# is_int() ---------------------------------------------------------------------


test_that("is_int() only checks type only when `n` is null", {
    expect_true(is_int(integer(1L)))
    expect_true(is_int(integer(2L)))
    expect_false(is_int(logical(1L)))
    expect_false(is_int(logical(2L)))
})

test_that("is_int() also checks length when `n` is not null", {
    expect_true(is_int(integer(1L),  1L))
    expect_true(is_int(integer(2L),  2L))
    expect_false(is_int(logical(2L), 2L))
})

test_that("is_int() coerces `n` when it is not an integer", {
    expect_true(is_int(integer(1L), "1"))
})

test_that("is_int() checks for na values when `.na` is false", {
    expect_true(is_int(NA_integer_,         NULL, TRUE))
    expect_false(is_int(NA_integer_,        NULL, FALSE))
    expect_false(is_int(c(1L, NA_integer_), 2L,   FALSE))
})


# is_dbl() ---------------------------------------------------------------------


test_that("is_dbl() only checks type only when `n` is null", {
    expect_true(is_dbl(double(1L)))
    expect_true(is_dbl(double(2L)))
    expect_false(is_dbl(logical(1L)))
    expect_false(is_dbl(logical(2L)))
})

test_that("is_dbl() also checks length when `n` is not null", {
    expect_true(is_dbl(double(1L),   1L))
    expect_true(is_dbl(double(2L),   2L))
    expect_false(is_dbl(logical(2L), 2L))
})

test_that("is_dbl() coerces `n` when it is not an integer", {
    expect_true(is_dbl(double(1L), "1"))
})

test_that("is_dbl() checks for na values when `.na` is false", {
    expect_true(is_dbl(NA_real_,          NULL, TRUE))
    expect_false(is_dbl(NA_real_,         NULL, FALSE))
    expect_false(is_dbl(c(1.0, NA_real_), 2L,   FALSE))
})


# is_cpx() ---------------------------------------------------------------------


test_that("is_cpx() only checks type only when `n` is null", {
    expect_true(is_cpx(complex(1L)))
    expect_true(is_cpx(complex(2L)))
    expect_false(is_cpx(logical(1L)))
    expect_false(is_cpx(logical(2L)))
})

test_that("is_cpx() also checks length when `n` is not null", {
    expect_true(is_cpx(complex(1L),  1L))
    expect_true(is_cpx(complex(2L),  2L))
    expect_false(is_cpx(logical(2L), 2L))
})

test_that("is_cpx() coerces `n` when it is not an integer", {
    expect_true(is_cpx(complex(1L), "1"))
})

test_that("is_cpx() checks for na values when `.na` is false", {
    expect_true(is_cpx(NA_complex_,           NULL, TRUE))
    expect_false(is_cpx(NA_complex_,          NULL, FALSE))
    expect_false(is_cpx(c(1+1i, NA_complex_), 2L,   FALSE))
})


# is_chr() ---------------------------------------------------------------------


test_that("is_chr() only checks type only when `n` is null", {
    expect_true(is_chr(character(1L)))
    expect_true(is_chr(character(2L)))
    expect_false(is_chr(logical(1L)))
    expect_false(is_chr(logical(2L)))
})

test_that("is_chr() also checks length when `n` is not null", {
    expect_true(is_chr(character(1L), 1L))
    expect_true(is_chr(character(2L), 2L))
    expect_false(is_chr(logical(2L),  2L))
})

test_that("is_chr() coerces `n` when it is not an integer", {
    expect_true(is_chr(character(1L), "1"))
})

test_that("is_chr() checks for na values when `.na` is false", {
    expect_true(is_chr(NA_character_,          NULL, TRUE))
    expect_false(is_chr(NA_character_,         NULL, FALSE))
    expect_false(is_chr(c("1", NA_character_), 2L,   FALSE))
})


# is_ato() ---------------------------------------------------------------------


test_that("is_ato() only checks type only when `n` is null", {
    expect_true(is_ato(logical(1L)))
    expect_true(is_ato(integer(1L)))
    expect_true(is_ato(double(1L)))
    expect_true(is_ato(numeric(1L)))
    expect_true(is_ato(complex(1L)))
    expect_true(is_ato(character(1L)))
    expect_true(is_ato(raw(1L)))
    expect_false(is_ato(vector(mode = "list", length = 1L)))
    expect_false(is_ato(vector(mode = "list", length = 2L)))
})

test_that("is_ato() also checks length when `n` is not null", {
    expect_true(is_ato(logical(1L),   1L))
    expect_true(is_ato(logical(2L),   2L))
    expect_true(is_ato(integer(1L),   1L))
    expect_true(is_ato(integer(2L),   2L))
    expect_true(is_ato(double(1L),    1L))
    expect_true(is_ato(double(2L),    2L))
    expect_true(is_ato(numeric(1L),   1L))
    expect_true(is_ato(numeric(2L),   2L))
    expect_true(is_ato(complex(1L),   1L))
    expect_true(is_ato(complex(2L),   2L))
    expect_true(is_ato(character(1L), 1L))
    expect_true(is_ato(character(2L), 2L))
    expect_true(is_ato(raw(1L),       1L))
    expect_true(is_ato(raw(2L),       2L))
    expect_false(is_ato(vector(mode = "list", length = 1L), 1L))
    expect_false(is_ato(vector(mode = "list", length = 2L), 2L))
})

test_that("is_ato() coerces `n` when it is not an integer", {
    expect_true(is_ato(logical(1L), "1"))
})

test_that("is_ato() checks for na values when `.na` is false", {
    expect_true(is_lgl(NA,            NULL))
    expect_true(is_int(NA_integer_,   NULL))
    expect_true(is_dbl(NA_real_,      NULL))
    expect_true(is_cpx(NA_complex_,   NULL))
    expect_true(is_chr(NA_character_, NULL))
    expect_false(is_ato(c(TRUE, NA),           2L, FALSE))
    expect_false(is_ato(c(1L, NA_integer_),    2L, FALSE))
    expect_false(is_ato(c(1.0, NA_real_),      2L, FALSE))
    expect_false(is_ato(c(1.0, NA_real_),      2L, FALSE))
    expect_false(is_ato(c(1+1i, NA_complex_),  2L, FALSE))
    expect_false(is_ato(c("1", NA_character_), 2L, FALSE))
    expect_true(is_ato(raw(1L),                1L, FALSE))
})


# is_lst() ---------------------------------------------------------------------


test_that("is_lst() only checks type only when `n` is null", {
    expect_true(is_lst(vector(mode = "list", 1L)))
    expect_true(is_lst(vector(mode = "list", 2L)))
    expect_false(is_lst(logical(1L)))
    expect_false(is_lst(logical(2L)))
})

test_that("is_lst() also checks length when `n` is not null", {
    expect_true(is_lst(vector(mode = "list", 1L), 1L))
    expect_true(is_lst(vector(mode = "list", 2L), 2L))
    expect_false(is_lst(logical(2L), 2L))
})

test_that("is_lst() coerces `n` when it is not an integer", {
    expect_true(is_lst(vector(mode = "list", 1L), "1"))
})

test_that("is_lst() checks for na values when `.na` is false", {
    expect_true(is_lst(list(NA), 1L))
    expect_true(is_lst(list(list(NA)), 1L, FALSE)) # no recursion
    expect_false(is_lst(list(NA), 1L, FALSE))
})


# is_scalar_lgl() --------------------------------------------------------------


test_that("is_scalar_lgl() works", {
    expect_true(is_scalar_lgl(logical(1L)))
    expect_false(is_scalar_lgl(logical(0L)))
    expect_false(is_scalar_lgl(logical(2L)))
    expect_false(is_scalar_lgl(NA))
    expect_true(is_scalar_lgl(NA, TRUE))
})


# is_scalar_int() --------------------------------------------------------------


test_that("is_scalar_int() works", {
    expect_true(is_scalar_int(integer(1L)))
    expect_false(is_scalar_int(integer(0L)))
    expect_false(is_scalar_int(integer(2L)))
    expect_false(is_scalar_int(NA_integer_))
    expect_true(is_scalar_int(NA_integer_, TRUE))
})


# is_scalar_dbl() --------------------------------------------------------------


test_that("is_scalar_dbl() works", {
    expect_true(is_scalar_dbl(double(1L)))
    expect_false(is_scalar_dbl(double(0L)))
    expect_false(is_scalar_dbl(double(2L)))
    expect_false(is_scalar_dbl(NA_real_))
    expect_true(is_scalar_dbl(NA_real_, TRUE))
})


# is_scalar_cpx() --------------------------------------------------------------


test_that("is_scalar_cpx() works", {
    expect_true(is_scalar_cpx(complex(1L)))
    expect_false(is_scalar_cpx(complex(0L)))
    expect_false(is_scalar_cpx(complex(2L)))
    expect_false(is_scalar_cpx(NA_complex_))
    expect_true(is_scalar_cpx(NA_complex_, TRUE))
})


# is_scalar_chr() --------------------------------------------------------------


test_that("is_scalar_chr() works", {
    expect_true(is_scalar_chr(character(1L)))
    expect_false(is_scalar_chr(character(0L)))
    expect_false(is_scalar_chr(character(2L)))
    expect_false(is_scalar_chr(NA_character_))
    expect_true(is_scalar_chr(NA_character_, TRUE))
})


# is_scalar_ato() --------------------------------------------------------------


test_that("is_scalar_ato() works", {
    expect_true(is_scalar_ato(raw(1L)))
    expect_false(is_scalar_ato(raw(0L)))
    expect_false(is_scalar_ato(raw(2L)))
    expect_false(is_scalar_ato(NA))
    expect_true(is_scalar_ato(NA, TRUE))
})


# is_scalar_lst() --------------------------------------------------------------


test_that("is_scalar_lst() works", {
    expect_true(is_scalar_lst(vector(mode = "list",  1L)))
    expect_false(is_scalar_lst(vector(mode = "list", 2L)))
    expect_false(is_scalar_lst(logical(1L)))
    expect_false(is_scalar_lst(list(NA)))
    expect_true(is_scalar_lst(list(NA), TRUE))
})