tests/testthat/test_ArgValidation.R

In DSkrzypiec/oRtrack: Object References Tracker

# ---------------------------------------------------------------
#
#    Author     : Damian Skrzypiec <damian.j.skrzypiec@gmail.com>
#
#    Date       : 2017-12-29 23:41:45
#
#    Description: Test for arg validation funcs.
#
# ---------------------------------------------------------------

testthat::context("Argument Validation")



testthat::test_that("isNumeric func", {
    testthat::expect_error(isNumeric("string"))
    testthat::expect_error(isNumeric(new.env()))
    testthat::expect_error(isNumeric(TRUE))
    testthat::expect_error(isNumeric(function(...){}))

    testthat::expect_silent(isNumeric(123))
    testthat::expect_silent(isNumeric(rnorm(1)))
    testthat::expect_silent(isNumeric(pi))
})



testthat::test_that("isInRange func", {
    testthat::expect_error(isInRange("string", 0, 1))
    testthat::expect_error(isInRange("string", "0", 1))
    testthat::expect_error(isInRange(5, 0, 1))

    testthat::expect_silent(isInRange(20, 15, 25))
    testthat::expect_silent(isInRange(0.0001, -1, 1))
})



testthat::test_that("isCharacter func", {
    testthat::expect_error(isCharacter(TRUE))
    testthat::expect_error(isCharacter(rnorm(10)))
    testthat::expect_error(isCharacter(function(...){}))
    testthat::expect_error(isCharacter(new.env()))

    testthat::expect_silent(isCharacter("string"))
    testthat::expect_silent(isCharacter(""))
    testthat::expect_silent(sample(LETTERS, size = 5, replace = TRUE))
})



testthat::test_that("isLogical func", {
    testthat::expect_error(isLogical(rnorm(1)))
    testthat::expect_error(isLogical("string"))
    testthat::expect_error(isLogical(function(...){}))
    testthat::expect_error(isLogical(new.env()))

    testthat::expect_silent(isLogical(TRUE))
    testthat::expect_silent(isLogical(FALSE))
    testthat::expect_silent(isLogical(1 == 1))
    testthat::expect_silent(isLogical(1:100 < 50))
})



testthat::test_that("isList func", {
    testthat::expect_error(isList("string"))
    testthat::expect_error(isList(function(...){}))
    testthat::expect_error(isList(rnorm(100)))
    testthat::expect_error(isList(LETTERS))

    testthat::expect_silent(isList(list()))
    testthat::expect_silent(isList(data.frame()))
    testthat::expect_silent(isList(list(x = 1, y = list())))
})



testthat::test_that("isDataFrame func", {
    testthat::expect_error(isDataframe(1))
    testthat::expect_error(isDataframe(function(...){}))
    testthat::expect_error(isDataframe("string"))
    testthat::expect_error(isDataframe(new.env()))

    testthat::expect_silent(isDataframe(data.frame()))
    testthat::expect_silent(isDataframe(iris))
    testthat::expect_silent(isDataframe(cars))
    testthat::expect_silent(isDataframe(data.frame(x = 1:10, y = rnorm(10))))
})



testthat::test_that("isOfClass func", {
    testthat::expect_error(isOfClass(list(), "numeric"))
    testthat::expect_error(isOfClass(function(...){}, "character"))
    testthat::expect_error(isOfClass("string", "list"))

    testthat::expect_silent(isOfClass(list(), "list"))
    testthat::expect_silent(isOfClass(function(...){}, "function"))
    testthat::expect_silent(isOfClass(LETTERS, "character"))
})



testthat::test_that("isVectorTheSame func", {
    testthat::expect_false(isVectorsTheSame(1:10, rnorm(10)))
    testthat::expect_false(isVectorsTheSame(10:1, 1:10))
    testthat::expect_false(isVectorsTheSame(rnorm(10), rnorm(10, mean = 10)))

    testthat::expect_true(isVectorsTheSame(1:1000, 1:1000))
    testthat::expect_true(isVectorsTheSame(LETTERS, LETTERS))
})



testthat::test_that("hasTheSameLength func", {
    testthat::expect_error(hasTheSameLength(1:10, 1:1000))
    testthat::expect_error(hasTheSameLength(letters, 1:1000))
    testthat::expect_error(hasTheSameLength(numeric(), rnorm(10)))

    testthat::expect_silent(hasTheSameLength(1:1000, 1000:1))
    testthat::expect_silent(hasTheSameLength(numeric(), character()))
    testthat::expect_silent(hasTheSameLength(rnorm(100), rnorm(100)))
})