library(lgpr)
# -------------------------------------------------------------------------
context("Argument validation")
test_that("check_allowed throws error for invalid input", {
expect_error(check_allowed(arg = c("moi", "hei"), allowed = c("moi", "hei")))
expect_error(check_allowed(arg = c("moi"), allowed = c("moi")))
expect_error(check_allowed(arg = "juu", allowed = c("moi", "joo")))
expect_error(check_allowed(arg = "juu", allowed = c("juu", "juu")))
})
test_that("check_allowed works correctly for valid input", {
idx <- check_allowed(arg = c("hei"), allowed = c("moi", "hei"))
expect_equal(idx, 2)
})
test_that("check_type works correctly", {
out <- check_type(3.4, "numeric")
expect_true(out)
reason <- "must be an object of type <list>! Found = <numeric>"
expect_error(check_type(3.4, "list"), reason)
})
test_that("check_function works correctly", {
out1 <- check_type(function(x) base::mean(x), "function")
expect_true(out1)
reason <- "must be an object of type <function>"
expect_error(check_type("hello", "function"), reason)
})
test_that("check_length works correctly", {
out1 <- check_length("moi", 1)
out2 <- check_length(c(4, 3, 2), 3)
expect_true(out1)
expect_true(out2)
reason <- "has length 3, but its length should be 5"
expect_error(check_length(c(4, 3, 2), 5), reason)
})
test_that("check_lengths works correctly", {
a1 <- c(1, 2)
a2 <- c(3, 2, 1)
a3 <- c(3, 2, 1)
expect_true(check_lengths(a2, a3))
reason <- "lengths of a1 and a3 must match! found = 2 and 3"
expect_error(check_lengths(a1, a3), reason)
})
test_that("check_not_null works correctly", {
a1 <- c(1, 2)
a2 <- NULL
expect_true(check_not_null(a1))
reason <- "a2 should not be NULL"
expect_error(check_not_null(a2), reason)
})
test_that("check_interval works correctly", {
x <- 0.3
reason <- "<x> must be on the interval"
expect_error(check_interval(x, 1, 2), reason)
expect_true(check_interval(1.53, 1, 2))
})
test_that("check_all_leq works correctly", {
x <- c(4, 3, 4, 5)
y <- c(4, 3, 2, 1)
reason <- "value of <x> is larger than value of <y> at index 3"
expect_error(check_all_leq(x, y), reason)
expect_true(check_all_leq(c(1, 1, 1, 1), y))
})
test_that("check_not_named works correctly", {
x <- c(4, 3, 4, 5)
expect_true(check_not_named(x))
names(x) <- c("hei", "hey", "ho", "jea")
reason <- "<x> should not have names! found = "
expect_error(check_not_named(x), reason)
})
test_that("check_named works correctly", {
x <- c(4, 3, 4, 5)
expect_error(check_named(x), "<x> must have names")
names(x) <- c("hei", "hey", "ho", "jea")
expect_true(check_named(x))
})
test_that("check_numeric works correctly", {
reason <- "must be numeric"
expect_error(check_numeric("moi"), reason)
expect_true(check_numeric(1))
})
test_that("check_null works correctly", {
a <- 123
msg <- "should be NULL! Reason: no reason"
expect_error(check_null(a, "no reason"), msg)
expect_true(check_null(NULL))
})
test_that("check_false works correctly", {
a <- TRUE
reason <- "to be FALSE"
expect_error(check_false(a), reason)
expect_error(check_false(2), reason)
expect_true(check_false(0))
expect_true(check_false(!a))
})
test_that("check_dim works correctly", {
a <- array(0, c(2, 3, 4))
expect_true(check_dim(a, 3))
reason <- "number of dimensions of <a> must be 2! found = 3"
expect_error(check_dim(a, 2), reason)
})
test_that("check_length_leq works correctly", {
a <- c(2, 3, 4, 5)
expect_true(check_length_geq(a, 1))
expect_true(check_length_geq(a, 4))
reason <- "has length 4, but its length should be at least 5!"
expect_error(check_length_geq(a, 5), reason)
})
test_that("check_length_1_or works correctly", {
a <- c(2, 3, 4, 5)
expect_true(check_length_1_or(a, 4))
reason <- "has length 4, but its length should be 3 or one"
expect_error(check_length_1_or(a, 3), reason)
a <- c(2)
expect_true(check_length_1_or(a, 4))
})
test_that("check_integer_all works correctly", {
a <- c(2, 3, 4, 5)
expect_true(check_integer_all(a))
a[2] <- 2.99999
reason <- "<a> must have only integer values"
expect_error(check_integer_all(a), reason)
})
test_that("check_unique works correctly", {
a <- c(2)
b <- c("moi", "hei")
expect_true(check_unique(a))
expect_true(check_unique(b))
a <- c("moi", "moi")
reason <- "<a> must have only unique elements"
expect_error(check_unique(a), reason)
})
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.