Nothing
# Test data_slice() methods
# load packages
library("testthat")
library("gratia")
library("mgcv")
test_that("data_slice works for a GAM", {
expect_silent(ds <- data_slice(su_m_quick_eg1,
x1 = evenly(x1, n = 50),
x2 = evenly(x2, n = 50)))
expect_s3_class(ds, "tbl_df")
expect_named(ds, c("x1", "x2", "x0", "x3"))
expect_message(data_slice(su_m_quick_eg1,
x1 = evenly(x1, n = 50), var2 = "foo"),
"Some specified variable\\(s\\) not used in model")
expect_message(data_slice(su_m_quick_eg1,
x1 = evenly(x1, n = 50), var2 = "foo"),
"var2")
})
test_that("process_slice_data works when passed a 1-row data frame, tibble, or list", {
expect_silent(result1 <- process_slice_data(quick_eg1[1, ]))
expect_silent(result2 <- process_slice_data(as_tibble(quick_eg1[1, ])))
expect_silent(result3 <- process_slice_data(as.list(quick_eg1[1, ])))
expect_equal(NROW(result1), 1L)
expect_equal(NROW(result2), 1L)
expect_equal(NROW(result3), 1L)
expect_equal(result1, result2)
expect_equal(result1, result3)
expect_equal(result2, result3)
})
test_that("process_slice_data fails when passed a data frame with > 1 rows", {
expect_error(process_slice_data(quick_eg1),
"'data' should have 1 row only. Supplied <200>",
fixed = TRUE)
})
test_that("process_slice_data fails when passed a matrix", {
expect_error(process_slice_data(as.matrix(quick_eg1)),
"'data' should be a tibble, data frame, or list. Supplied <matrix>",
fixed = TRUE)
})
test_that("process_slice_data fails when passed a list with elements of length > 1", {
expect_error(process_slice_data(as.list(quick_eg1[1:2, ])),
"If 'data' is a list, it should be a list of length-1 vectors",
fixed = TRUE)
})
test_that("process_slice_var fails when passed a logical variable", {
dat2 <- cbind(quick_eg1,
foo = sample(c(TRUE,FALSE), nrow(quick_eg1), replace = TRUE))
expect_error(process_slice_var("foo", dat2),
"Variable <foo> must be a factor or numeric vector. Found <character>",
fixed = TRUE)
})
test_that("process_slice_var fails when `x` is not character", {
bar <- 1
expect_error(process_slice_var(bar, dat2),
"Supplied 'x' is not character.",
fixed = TRUE)
})
test_that("process_slice_var returns NULL when `x` is NULL", {
expect_identical(process_slice_var(NULL, dat2), NULL)
})
#set.seed(42)
#dat <- gamSim(4, n = 400, verbose = FALSE)
#mf <- gam(y ~ fac + s(x2, by = fac) + s(x0), data = dat)
test_that("data_slice works for a GAM with factor by", {
expect_silent(ds <- data_slice(su_m_factor_by,
x2 = evenly(x2),
fac = evenly(fac)))
expect_s3_class(ds, "tbl_df")
expect_named(ds, c("x2", "fac", "x0"))
})
test_that("default data_slice method fails gracefully", {
expect_error(data_slice(su_eg4),
"Don't know how to create a data slice from <tbl_df>",
fixed = TRUE)
})
test_that("value_closest_to_median fails for character vectors", {
expect_error(value_closest_to_median(LETTERS),
"'x' must be a factor or numeric vector. Supplied <character>",
fixed = TRUE)
})
test_that("value_closest_to_median fails for logical vectors", {
expect_error(value_closest_to_median(sample(c(TRUE, FALSE), 50,
replace = TRUE)),
"'x' must be a factor or numeric vector. Supplied <logical>",
fixed = TRUE)
})
test_that("value_closest_to_median works with a factor", {
expect_silent( result <-
gratia:::value_closest_to_median(su_eg4[["fac"]]) )
expect_identical(factor(1, levels = c(1,2,3)), result)
})
# typical_values()
test_that("typical_values works with a simple GAM", {
expect_silent(tv <- typical_values(su_m_quick_eg1))
expect_s3_class(tv, "tbl_df")
expect_identical(nrow(tv), 1L)
expect_identical(ncol(tv), 4L)
})
test_that("typical_values works when including terms", {
expect_silent(tv <- typical_values(su_m_quick_eg1, vars = c(x0, x2)))
expect_s3_class(tv, "tbl_df")
expect_identical(nrow(tv), 1L)
expect_identical(ncol(tv), 2L)
expect_identical(names(tv), c("x0","x2"))
})
test_that("typical_values works when excluding terms", {
expect_silent(tv <- typical_values(su_m_quick_eg1, vars = !c(x0, x2)))
expect_s3_class(tv, "tbl_df")
expect_identical(nrow(tv), 1L)
expect_identical(ncol(tv), 2L)
expect_identical(names(tv), c("x1","x3"))
})
# factor_combos()
test_that("factor_combos works with a simple GAM", {
expect_silent(fc <- factor_combos(m_para_sm))
expect_s3_class(fc, "tbl_df")
expect_identical(nrow(fc), 12L)
expect_identical(ncol(fc), 2L)
expect_named(fc, c("fac", "ff"))
})
test_that("factor_combos works when including terms", {
expect_silent(fc <- factor_combos(m_para_sm, vars = fac))
expect_s3_class(fc, "tbl_df")
expect_identical(nrow(fc), 3L)
expect_identical(ncol(fc), 1L)
expect_named(fc, c("fac"))
})
test_that("factor_combos works when excluding terms", {
expect_silent(fc <- factor_combos(m_para_sm, vars = !fac))
expect_s3_class(fc, "tbl_df")
expect_identical(nrow(fc), 4L)
expect_identical(ncol(fc), 1L)
expect_named(fc, c("ff"))
})
test_that("factor_combos works when there are no factor terms", {
expect_message(fc <- factor_combos(m_gam, vars = !fac),
"Model contains no factor terms")
expect_identical(fc, NULL)
})
# data_combos()
test_that("data_combos works with a GAM", {
expect_silent(dc <- data_combos(m_para_sm))
expect_s3_class(dc, "tbl_df")
expect_identical(nrow(dc), 12L)
expect_identical(ncol(dc), 5L)
expect_named(dc, c("fac", "ff", "x0", "x1", "x2"))
})
test_that("data_combos works when including terms", {
expect_silent(dc <- data_combos(m_para_sm, vars = c(fac, x0)))
expect_s3_class(dc, "tbl_df")
expect_identical(nrow(dc), 12L)
expect_identical(ncol(dc), 2L)
expect_named(dc, c("fac", "x0"))
})
test_that("data_combos works when exluding terms", {
expect_silent(dc <- data_combos(m_para_sm, vars = !c(fac, x0)))
expect_s3_class(dc, "tbl_df")
expect_identical(nrow(dc), 12L)
expect_identical(ncol(dc), 3L)
expect_named(dc, c("ff", "x1", "x2"))
})
test_that("data_combos works when there are no factor terms", {
expect_message(dc <- data_combos(m_gam),
"Model contains no factor terms")
expect_identical(nrow(dc), 1L)
expect_identical(ncol(dc), 4L)
expect_named(dc, c("x0", "x1", "x2", "x3"))
})
# Test data_slice with models that have an offset(s) - # 189
test_that("data_slice with no args works with models with an offset", {
expect_silent(ds <- data_slice(m_1_smooth_offset))
expect_identical(nrow(ds), 1L)
expect_identical(ncol(ds), 2L)
expect_identical(ds$off, 2)
})
test_that("data_slice with works with models with an offset", {
expect_silent(ds <- data_slice(m_1_smooth_offset, off = 1))
expect_identical(nrow(ds), 1L)
expect_identical(ncol(ds), 2L)
expect_identical(ds$off, 1)
})
test_that("data_slice with works with models with an offset", {
expect_silent(ds <- data_slice(m_1_smooth_offset, x0 = evenly(x0, n = 50),
off = 1))
expect_identical(nrow(ds), 50L)
expect_identical(ncol(ds), 2L)
expect_identical(ds$off, rep(1, length.out = 50))
})
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.